From 6875b85eff4bc99d38289a79cb1355cedf15e3f2 Mon Sep 17 00:00:00 2001 From: Louis Dionne Date: Tue, 31 Mar 2026 17:21:17 -0400 Subject: [PATCH 001/143] [API] Design and implement the v5 API Assisted-by: Claude Code --- docs/api.rst | 21 + docs/design/v5-api.md | 179 +++ docs/v5-api-implementation-plan.md | 785 ++++++++++ lnt/server/api/__init__.py | 0 lnt/server/api/v5/__init__.py | 35 + lnt/server/api/v5/auth.py | 163 ++ lnt/server/api/v5/endpoints/__init__.py | 53 + lnt/server/api/v5/endpoints/admin.py | 127 ++ lnt/server/api/v5/endpoints/discovery.py | 52 + lnt/server/api/v5/endpoints/field_changes.py | 245 +++ lnt/server/api/v5/endpoints/machines.py | 310 ++++ lnt/server/api/v5/endpoints/orders.py | 249 +++ lnt/server/api/v5/endpoints/profiles.py | 182 +++ lnt/server/api/v5/endpoints/query.py | 467 ++++++ lnt/server/api/v5/endpoints/regressions.py | 554 +++++++ lnt/server/api/v5/endpoints/runs.py | 237 +++ lnt/server/api/v5/endpoints/samples.py | 113 ++ lnt/server/api/v5/endpoints/test_suites.py | 256 ++++ lnt/server/api/v5/endpoints/tests.py | 90 ++ lnt/server/api/v5/errors.py | 216 +++ lnt/server/api/v5/etag.py | 66 + lnt/server/api/v5/helpers.py | 216 +++ lnt/server/api/v5/middleware.py | 138 ++ lnt/server/api/v5/pagination.py | 115 ++ lnt/server/api/v5/schemas/__init__.py | 19 + lnt/server/api/v5/schemas/admin.py | 83 + lnt/server/api/v5/schemas/common.py | 134 ++ lnt/server/api/v5/schemas/machines.py | 130 ++ lnt/server/api/v5/schemas/orders.py | 136 ++ lnt/server/api/v5/schemas/profiles.py | 92 ++ lnt/server/api/v5/schemas/query.py | 101 ++ lnt/server/api/v5/schemas/regressions.py | 344 +++++ lnt/server/api/v5/schemas/runs.py | 113 ++ lnt/server/api/v5/schemas/samples.py | 57 + lnt/server/api/v5/schemas/test_suites.py | 142 ++ lnt/server/api/v5/schemas/tests.py | 43 + lnt/server/db/fieldchange.py | 2 + lnt/server/db/migrations/upgrade_18_to_19.py | 168 ++ lnt/server/db/migrations/upgrade_19_to_20.py | 50 + lnt/server/db/migrations/upgrade_20_to_21.py | 49 + lnt/server/db/regression.py | 2 + lnt/server/db/testsuite.py | 10 + lnt/server/db/testsuitedb.py | 26 +- lnt/server/db/v4db.py | 44 + lnt/server/ui/app.py | 6 + lnt/server/ui/regression_views.py | 2 + pyproject.toml | 1 + tests/lit.cfg | 2 +- tests/server/__init__.py | 0 tests/server/api/__init__.py | 0 tests/server/api/v5/__init__.py | 0 tests/server/api/v5/test_access_log.py | 182 +++ tests/server/api/v5/test_admin.py | 436 ++++++ tests/server/api/v5/test_auth.py | 222 +++ tests/server/api/v5/test_discovery.py | 114 ++ tests/server/api/v5/test_errors.py | 190 +++ tests/server/api/v5/test_etag.py | 69 + tests/server/api/v5/test_field_changes.py | 857 +++++++++++ tests/server/api/v5/test_helpers.py | 94 ++ tests/server/api/v5/test_integration.py | 537 +++++++ tests/server/api/v5/test_machines.py | 762 +++++++++ tests/server/api/v5/test_orders.py | 645 ++++++++ tests/server/api/v5/test_pagination.py | 236 +++ tests/server/api/v5/test_profiles.py | 389 +++++ tests/server/api/v5/test_query.py | 1363 +++++++++++++++++ .../api/v5/test_regression_state_mapping.py | 69 + tests/server/api/v5/test_regressions.py | 1123 ++++++++++++++ tests/server/api/v5/test_runs.py | 1242 +++++++++++++++ tests/server/api/v5/test_samples.py | 468 ++++++ tests/server/api/v5/test_test_suites.py | 776 ++++++++++ tests/server/api/v5/test_tests.py | 300 ++++ tests/server/api/v5/v5_test_helpers.py | 189 +++ tests/server/db/CreateV4TestSuiteInstance.py | 3 + tests/server/ui/change_processing.py | 63 +- 74 files changed, 16950 insertions(+), 4 deletions(-) create mode 100644 docs/design/v5-api.md create mode 100644 docs/v5-api-implementation-plan.md create mode 100644 lnt/server/api/__init__.py create mode 100644 lnt/server/api/v5/__init__.py create mode 100644 lnt/server/api/v5/auth.py create mode 100644 lnt/server/api/v5/endpoints/__init__.py create mode 100644 lnt/server/api/v5/endpoints/admin.py create mode 100644 lnt/server/api/v5/endpoints/discovery.py create mode 100644 lnt/server/api/v5/endpoints/field_changes.py create mode 100644 lnt/server/api/v5/endpoints/machines.py create mode 100644 lnt/server/api/v5/endpoints/orders.py create mode 100644 lnt/server/api/v5/endpoints/profiles.py create mode 100644 lnt/server/api/v5/endpoints/query.py create mode 100644 lnt/server/api/v5/endpoints/regressions.py create mode 100644 lnt/server/api/v5/endpoints/runs.py create mode 100644 lnt/server/api/v5/endpoints/samples.py create mode 100644 lnt/server/api/v5/endpoints/test_suites.py create mode 100644 lnt/server/api/v5/endpoints/tests.py create mode 100644 lnt/server/api/v5/errors.py create mode 100644 lnt/server/api/v5/etag.py create mode 100644 lnt/server/api/v5/helpers.py create mode 100644 lnt/server/api/v5/middleware.py create mode 100644 lnt/server/api/v5/pagination.py create mode 100644 lnt/server/api/v5/schemas/__init__.py create mode 100644 lnt/server/api/v5/schemas/admin.py create mode 100644 lnt/server/api/v5/schemas/common.py create mode 100644 lnt/server/api/v5/schemas/machines.py create mode 100644 lnt/server/api/v5/schemas/orders.py create mode 100644 lnt/server/api/v5/schemas/profiles.py create mode 100644 lnt/server/api/v5/schemas/query.py create mode 100644 lnt/server/api/v5/schemas/regressions.py create mode 100644 lnt/server/api/v5/schemas/runs.py create mode 100644 lnt/server/api/v5/schemas/samples.py create mode 100644 lnt/server/api/v5/schemas/test_suites.py create mode 100644 lnt/server/api/v5/schemas/tests.py create mode 100644 lnt/server/db/migrations/upgrade_18_to_19.py create mode 100644 lnt/server/db/migrations/upgrade_19_to_20.py create mode 100644 lnt/server/db/migrations/upgrade_20_to_21.py create mode 100644 tests/server/__init__.py create mode 100644 tests/server/api/__init__.py create mode 100644 tests/server/api/v5/__init__.py create mode 100644 tests/server/api/v5/test_access_log.py create mode 100644 tests/server/api/v5/test_admin.py create mode 100644 tests/server/api/v5/test_auth.py create mode 100644 tests/server/api/v5/test_discovery.py create mode 100644 tests/server/api/v5/test_errors.py create mode 100644 tests/server/api/v5/test_etag.py create mode 100644 tests/server/api/v5/test_field_changes.py create mode 100644 tests/server/api/v5/test_helpers.py create mode 100644 tests/server/api/v5/test_integration.py create mode 100644 tests/server/api/v5/test_machines.py create mode 100644 tests/server/api/v5/test_orders.py create mode 100644 tests/server/api/v5/test_pagination.py create mode 100644 tests/server/api/v5/test_profiles.py create mode 100644 tests/server/api/v5/test_query.py create mode 100644 tests/server/api/v5/test_regression_state_mapping.py create mode 100644 tests/server/api/v5/test_regressions.py create mode 100644 tests/server/api/v5/test_runs.py create mode 100644 tests/server/api/v5/test_samples.py create mode 100644 tests/server/api/v5/test_test_suites.py create mode 100644 tests/server/api/v5/test_tests.py create mode 100644 tests/server/api/v5/v5_test_helpers.py diff --git a/docs/api.rst b/docs/api.rst index 4bb49ec94..f476701f3 100644 --- a/docs/api.rst +++ b/docs/api.rst @@ -5,6 +5,27 @@ Accessing Data outside of LNT: REST API LNT provides comprehensive REST APIs to access and manage data stored in the LNT database. +v5 API (Recommended) +-------------------- + +The v5 API is the latest REST API for LNT. It provides interactive documentation via +Swagger UI, available at:: + + http:///api/v5/openapi/swagger-ui + +The OpenAPI 3.0 specification is also available in JSON format at:: + + http:///api/v5/openapi/openapi.json + +The v5 API uses Bearer token authentication, natural keys (machine names, test names) +instead of internal IDs, cursor-based pagination, and a standardized error format. +Refer to the Swagger UI for the complete list of endpoints and their parameters. + +v4 API (Legacy) +--------------- + +The v4 API is documented below for reference. New integrations should use the v5 API. + Quick Reference --------------- diff --git a/docs/design/v5-api.md b/docs/design/v5-api.md new file mode 100644 index 000000000..9aad91f20 --- /dev/null +++ b/docs/design/v5-api.md @@ -0,0 +1,179 @@ +R1: Framework and Standards + +- Implement using flask-smorest within the existing Flask application +- OpenAPI 3.x specification auto-generated from code annotations and marshmallow schemas +- Target Python 3.10+ +- New code lives in lnt/server/api/v5/ package, completely separate from existing API code +- Existing v4 API remains unchanged — no modifications to api.py or its behavior +- Reuse existing database models (SQLAlchemy schemas in testsuitedb.py, testsuite.py, etc.) but do not treat reuse of existing API implementation code as a requirement — write clean new implementations where +appropriate +- CORS headers enabled on all v5 endpoints (Access-Control-Allow-Origin: *) + +R2: URL Structure and Identifiers + +- Base path: /api/v5/{testsuite}/ +- Always uses the default database (no db_ prefix) +- Entities addressed by natural keys (machine name, test name) or server-generated UUIDs (runs, regressions, field changes) — never by internal auto-increment database IDs +- A discovery endpoint at GET /api/v5/ lists available test suites with links to their resources + +R3: Entity Endpoints + +Machines + +GET /machines — List (filterable, simple pagination) +POST /machines — Create machine independently +GET /machines/{machine_name} — Detail +PATCH /machines/{machine_name} — Update metadata/parameters (including rename) +DELETE /machines/{machine_name} — Delete machine and its runs +GET /machines/{machine_name}/runs — List runs for this machine (cursor-paginated) +Machines are also created implicitly if a run is submitted for a nonexistent machine. + +Orders + +GET /orders — List (cursor-paginated, filterable) +POST /orders — Create with metadata (git commit info, etc.) +GET /orders/{order_id} — Detail (includes previous/next order references) +PATCH /orders/{order_id} — Update metadata +Orders are read/create/update only — no delete. The order_id in the path is the primary order field value (e.g. the revision hash). If order fields are multi-valued and ambiguous, query parameters +disambiguate. Orders are also created implicitly during run submission. + +Runs + +GET /runs — List (cursor-paginated, filterable by machine=, after=, before=) +POST /runs — Submit run (server generates UUID, returns it) +GET /runs/{uuid} — Detail +DELETE /runs/{uuid} — Delete run +The UUID is a new field, generated server-side on submission. This requires a database schema migration to add the column. The submission endpoint requires JSON format with format_version '2'. Legacy formats (v0, v1) and non-JSON payloads are rejected. + +Tests + +GET /tests — List (cursor-paginated, filterable) +GET /tests/{test_name} — Detail +Read-only. Tests are created implicitly via run submission. + +Samples + +Samples are always accessed through their parent run — they have no external identifier of their own. +GET /runs/{uuid}/samples — All samples for a run (cursor-paginated) +GET /runs/{uuid}/samples?has_profile=true — Filter to samples with profiles +GET /runs/{uuid}/tests/{test_name}/samples — Samples for a specific test in a run +Read-only. Samples are created as part of run submission. + +Profiles + +Profiles are accessed through run + test name. Under the hood, the API finds the sample for that run+test that has a profile attached. +GET /runs/{uuid}/tests/{test_name}/profile — Profile metadata + top-level counters +GET /runs/{uuid}/tests/{test_name}/profile/functions — List functions with counters +GET /runs/{uuid}/tests/{test_name}/profile/functions/{fn_name} — Disassembly + per-instruction counters +Profiles are submitted as base64-encoded data within the run submission payload (existing format). No separate upload endpoint. + +Regressions + +GET /regressions — List (cursor-paginated, filterable by state=, machine=, test=) +POST /regressions — Create from field changes +GET /regressions/{uuid} — Detail (see response contents below) +PATCH /regressions/{uuid} — Update title, bug URL, state +DELETE /regressions/{uuid} — Delete +POST /regressions/{uuid}/merge — Merge source regressions into this one +POST /regressions/{uuid}/split — Split field changes into a new regression +GET /regressions/{uuid}/indicators — List field changes (cursor-paginated) +POST /regressions/{uuid}/indicators — Add field change +DELETE /regressions/{uuid}/indicators/{fc_uuid} — Remove field change +Regressions are identified by server-generated UUID (schema migration required). + +Regression states (string enum): +detected, staged, active, not_to_be_fixed, ignored, detected_fixed, fixed + +State transitions are unconstrained — any state can be set to any other state via PATCH. + +Regression detail response (GET /regressions/{uuid}) includes: +- uuid, title, bug, state +- Embedded list of indicators, each containing: + - field_change_uuid + - test_name, machine_name, field_name + - old_value, new_value + - start_order and end_order (the order field values, not internal IDs) + - run_uuid (the run where the change was detected) + +Field Changes (triage) + +GET /field-changes — List unassigned field changes (cursor-paginated, filterable by machine=, test=, field=) +POST /field-changes — Create a field change programmatically (references machine, test, metric, and orders by name) +POST /field-changes/{uuid}/ignore — Ignore a field change +DELETE /field-changes/{uuid}/ignore — Un-ignore a field change +Field changes are identified by server-generated UUID (schema migration required). +Creating a field change requires: machine (name), test (name), metric (name), old_value, new_value, start_order, end_order, and optionally run_uuid. All references are resolved by name/value, not internal ID. + +Time Series + +GET /query + Query params: machine={name}&test={name}&metric={name}&after_order={order}&before_order={order} + &after_time={iso8601}&before_time={iso8601}&sort={fields}&limit={n}&cursor={c} +The metric parameter is required; all other query parameters are optional. +Returns cursor-paginated time-series data for graphing. Uses field names (not indices) to be self-documenting. + +Schema and Fields + +Schema definitions and metric field metadata are returned as part of the test suite +detail response (GET /api/v5/test-suites/{name}) rather than as standalone endpoints. +The response includes a "schema" object containing machine_fields, run_fields, and +metrics (with name, type, display_name, unit, unit_abbrev, bigger_is_better for each). +There are no separate /fields or /schema endpoints. + +R4: Pagination + +- Cursor-based pagination for unbounded lists: runs, tests, orders, samples, field changes, regressions, regression indicators, time series +- Simple offset-based or unpaginated for bounded/small lists: machines, API keys +- Cursor-paginated response envelope: {"items": [...], "cursor": {"next": "...", "previous": "..."}} +- Default page size with configurable limit parameter +- Cursors are opaque strings (clients must not parse them) + +R5: Filtering and Sorting + +- Named query parameters per endpoint, documented in OpenAPI spec +- Supported filter types per endpoint (examples): + - machine=, test=, field=, name_contains=, name_prefix= + - after=, before= (for timestamps and order values) + - state= (for regressions, supports multiple values: ?state=active&state=detected) + - has_profile=true (for samples) + - sort=field_name (prefix with - for descending: sort=-start_time) +- Exact filters and available sort fields defined per endpoint in the OpenAPI spec + +R6: Response Format + +- All responses in JSON +- Standardized error format: +{"error": {"code": "not_found", "message": "Machine 'foo' not found in test suite 'nts'"}} +- Standard HTTP status codes: 200, 201, 204, 304, 400, 401, 403, 404, 409, 422 +- ETag headers on GET responses; support If-None-Match for conditional requests returning 304 Not Modified when data hasn't changed + +R7: Authentication and Authorization + +- Authorization: Bearer header on all requests +- API keys with scopes (each scope includes all scopes above it): + - read — all GET endpoints + - submit — submit runs (POST /runs), create orders (POST /orders) + - triage — modify regression state/title/bug, ignore/un-ignore field changes, create/merge/split regressions, manage regression indicators + - manage — create/update/delete machines; update orders; delete runs + - admin — create/revoke API keys +- Keys stored hashed in the database +- Admin endpoints (outside any test suite): +GET /api/v5/admin/api-keys — List keys (admin) +POST /api/v5/admin/api-keys — Create key (admin), returns the raw token once +DELETE /api/v5/admin/api-keys/{prefix} — Revoke key (admin) + +R8: Testing + +- All API endpoints must have automated tests +- Use current best practices for Flask API testing (e.g. pytest with Flask test client, or similar) +- Tests should cover: happy paths, error cases, authentication/authorization, pagination, filtering + +R9: Not in Scope (Deferred) + +- Webhooks / change notifications +- Bulk/batch query endpoints +- Multi-database support +- Rate limiting +- Run comparison / derived analytics endpoints +- Report endpoints (daily, summary, latest runs) +- Machine merge diff --git a/docs/v5-api-implementation-plan.md b/docs/v5-api-implementation-plan.md new file mode 100644 index 000000000..575729ccc --- /dev/null +++ b/docs/v5-api-implementation-plan.md @@ -0,0 +1,785 @@ +# LNT v5 REST API — Implementation Plan + +## 0. Prerequisites — VERIFIED + +### 0.1 flask-smorest + SQLAlchemy 1.3.24 Compatibility — PASS + +Verified: `flask-smorest==0.46.2` installs cleanly alongside `SQLAlchemy==1.3.24`. +pip does not force an SQLAlchemy upgrade. Transitive deps installed: +marshmallow 4.2.2, webargs, apispec. All imports work correctly. + +### 0.2 flask-smorest + Flask-RESTful Coexistence — PASS + +Verified: Both `flask_restful.Api(app)` and `flask_smorest.Api(app)` can be registered +on the same Flask app. A minimal test confirmed: +- v4-style Flask-RESTful endpoint returns 200 with correct JSON +- v5-style flask-smorest endpoint returns 200 with correct JSON +- OpenAPI spec is generated and accessible at the configured URL +- No error handler conflicts observed + +--- + +## 1. Dependencies + +Add to `pyproject.toml` under `[project.dependencies]`: + +``` +flask-smorest>=0.44.0 +``` + +This transitively installs `marshmallow>=4.0`, `webargs>=8.0.0`, `apispec>=6.0.0`. +(Tested: flask-smorest 0.46.2 with marshmallow 4.2.2, SQLAlchemy 1.3.24 unchanged.) + +Add to `[project.optional-dependencies].dev`: + +``` +pytest>=8.0 +``` + +(`pytest-flask` is not needed — Flask's built-in `test_client()` suffices.) + +--- + +## 2. Package Structure + +``` +lnt/server/api/ # NEW directory + __init__.py # empty + v5/ + __init__.py # create_v5_api() factory + middleware.py # testsuite resolution, CORS, request lifecycle + auth.py # Bearer token auth, API key model, scope decorators + errors.py # Standardized error handlers (blueprint-scoped) + pagination.py # Cursor-based and offset pagination utilities + etag.py # ETag computation and conditional request support + schemas/ + __init__.py # Base schema classes, dynamic schema factory + common.py # Error, pagination envelope schemas + machines.py # Machine request/response schemas + orders.py # Order request/response schemas + runs.py # Run request/response schemas + tests.py # Test schemas + samples.py # Sample schemas + profiles.py # Profile schemas + regressions.py # Regression, indicator, field change schemas + series.py # Time series schemas + admin.py # API key schemas + endpoints/ + __init__.py # register_all_endpoints() + discovery.py # GET /api/v5/ + machines.py # Machine CRUD + orders.py # Order CRU + runs.py # Run CRD + submission + tests.py # Test list/detail + samples.py # Sample listing (under runs) + profiles.py # Profile data (under runs/tests) + regressions.py # Regression CRUD + merge/split/indicators + field_changes.py # Field change triage + series.py # Time series query + admin.py # API key management +``` + +--- + +## 3. Database Migrations + +### 3.1 New migration: `upgrade_18_to_19.py` + +This migration adds: + +**A) UUID columns** to per-testsuite `Run`, `Regression`, and `FieldChange` tables: +- Column: `UUID`, String(36) — added **without** UNIQUE constraint (SQLite does not + support UNIQUE in ALTER TABLE ADD COLUMN) +- Backfill existing rows with `uuid.uuid4()` values **in batches** (1000 rows per batch) + to avoid OOM on large databases +- After backfill, create a unique index separately via `CREATE UNIQUE INDEX` +- The migration discovers test suites via the `TestSuite` table (pattern from upgrade_7_to_8.py) + +**B) `APIKey` table** (global, not per-testsuite): +- Created via raw DDL in the migration (NOT via ORM Base.metadata.create_all) +- Columns: ID (PK), Name (String 256), KeyPrefix (String 8), KeyHash (String 64, unique index), + Scope (String 32), CreatedAt (DateTime), LastUsedAt (DateTime nullable), IsActive (Boolean) + +### 3.2 Model changes in `testsuitedb.py` + +Add UUID column to dynamic model definitions: + +```python +# In Run class (around line 347): +uuid = Column("UUID", String(36), unique=True, index=True) + +# In FieldChange class (around line 605): +uuid = Column("UUID", String(36), unique=True, index=True) + +# In Regression class (around line 662): +uuid = Column("UUID", String(36), unique=True, index=True) +``` + +Ensure UUID is generated on creation: +- In `_getOrCreateRun()`: set `run.uuid = str(uuid.uuid4())` when creating a new run +- For the `merge='replace'` strategy: generate a NEW UUID (not reuse the old one), + since the old run is being replaced with different data +- In `new_regression()` in `regression.py`: set `regression.uuid = str(uuid.uuid4())` +- FieldChange UUIDs: set in `regenerate_fieldchanges_for_run()` in `fieldchange.py` when creating new FieldChanges + +### 3.3 APIKey runtime model + +Define a standalone SQLAlchemy model for `APIKey` using a declarative base (consistent +with the rest of the codebase), mapped to the table created by the migration. Use a +separate base to avoid contaminating the testsuite metadata and the per-suite bases. +The session used to query APIKey is engine-bound, not metadata-bound, so queries work +through the same session as other models. + +```python +# In lnt/server/api/v5/auth.py +from sqlalchemy.ext.declarative import declarative_base + +APIKeyBase = declarative_base() + +class APIKey(APIKeyBase): + __tablename__ = 'APIKey' + id = Column("ID", Integer, primary_key=True) + name = Column("Name", String(256), nullable=False) + key_prefix = Column("KeyPrefix", String(8), nullable=False) + key_hash = Column("KeyHash", String(64), nullable=False, unique=True, index=True) + scope = Column("Scope", String(32), nullable=False) + created_at = Column("CreatedAt", DateTime, nullable=False) + last_used_at = Column("LastUsedAt", DateTime, nullable=True) + is_active = Column("IsActive", Boolean, nullable=False, default=True) +``` + +--- + +## 4. Core Infrastructure + +### 4.1 App Registration (`lnt/server/api/v5/__init__.py`) + +```python +from flask_smorest import Api as SmorestApi + +def create_v5_api(app): + app.config.update({ + "API_TITLE": "LNT API", + "API_VERSION": "v5", + "OPENAPI_VERSION": "3.0.3", + "OPENAPI_URL_PREFIX": "/api/v5/openapi", + "OPENAPI_JSON_PATH": "openapi.json", + }) + smorest_api = SmorestApi(app) + + from .middleware import register_middleware + register_middleware(app) + + from .endpoints import register_all_endpoints + register_all_endpoints(smorest_api) + + return smorest_api +``` + +Integration in `app.py` — add after line 153 (`load_api_resources(app.api)`): + +```python +from lnt.server.api.v5 import create_v5_api +app.v5_api = create_v5_api(app) +``` + +### 4.2 Middleware (`middleware.py`) + +**Testsuite resolution** — `before_request` hook scoped to `/api/v5/` paths: + +1. Parse `testsuite_name` from URL (`request.view_args`) +2. Skip testsuite resolution for discovery (`/api/v5/`), admin (`/api/v5/admin/`), and OpenAPI spec paths +3. Open DB: `g.db = current_app.instance.get_database("default")` (use `current_app`, not `app`) + **Note**: `Instance.get_database()` returns a cached `V4DB` instance — it does NOT + create a new connection per request. Verified in `instance.py` line 76-77. + **Warning**: Do NOT call `Config.get_database()` — that creates a new V4DB every time. +4. Set `g.db_name = "default"` (needed by `import_from_string` and other code that reads `g.db_name`) +5. Create session: `g.db_session = g.db.make_session()` +6. Resolve testsuite (only when URL contains one): `g.ts = g.db.testsuite[testsuite_name]` +7. Register `teardown_request` to close/rollback the session + +**CORS** — `after_request` hook for `/api/v5/` paths: +``` +Access-Control-Allow-Origin: * (configurable) +Access-Control-Allow-Methods: GET, POST, PATCH, DELETE, OPTIONS +Access-Control-Allow-Headers: Authorization, Content-Type, If-None-Match +Access-Control-Expose-Headers: ETag, Location +Access-Control-Max-Age: 86400 +``` + +**Note**: Must also handle OPTIONS preflight requests correctly. Flask's +`provide_automatic_options` (True by default) generates OPTIONS responses, but the +`after_request` hook must ensure CORS headers are added to these responses too. +Alternatively, consider using `flask-cors` to avoid manual CORS implementation pitfalls. + +**Important**: For admin and discovery endpoints that need DB access (e.g., for auth +validation and listing test suites), the middleware must open a DB session even without +a testsuite context. Use a two-phase approach: always open a DB session for `/api/v5/` +paths, and only resolve the testsuite when the URL contains one. + +### 4.3 Authentication (`auth.py`) + +**Scope hierarchy** (linear, each level includes all below): + +| Scope | Level | Can do | +|-------|-------|--------| +| `read` | 0 | All GET endpoints | +| `submit` | 1 | Submit runs (POST /runs) | +| `triage` | 2 | Regression state/title/bug, ignore/un-ignore field changes, create/merge/split regressions | +| `manage` | 3 | Create/update/delete machines, orders; delete runs | +| `admin` | 4 | Create/revoke API keys | + +**Token validation flow:** +1. Extract token from `Authorization: Bearer ` header +2. Hash with SHA-256, look up in `APIKey` table +3. Verify `is_active == True` +4. Compare granted scope level against required scope level +5. If no token and endpoint requires only `read` scope: allow (unauthenticated reads, + matching v4 behavior). Configurable via `require_auth_for_reads` in lnt.cfg. + +**Bootstrap**: If the existing `api_auth_token` is configured in `lnt.cfg`, a Bearer +token matching it is treated as an `admin`-scoped key. This lets existing deployments +use the v5 API immediately and create proper scoped API keys via +`POST /api/v5/admin/api-keys` without any new CLI commands. + +**Decorator**: `@require_scope(scope_name)` — use on each endpoint method. + +### 4.4 Error Handling (`errors.py`) + +**Error handling scoped to v5 only** — do NOT register error handlers on `app` globally +(that would break v4 error format). Instead, customize error responses at the +`flask_smorest.Api` level by overriding `Api.handle_http_exception` or setting a custom +error handler. Since the `Api` object only handles requests routed through its blueprints, +this naturally scopes to v5 endpoints. + +**Note**: flask-smorest's `Blueprint` does NOT have an `errorhandler()` method that works +like Flask's. Error customization must happen at the `Api` level. + +For validation errors, flask-smorest/webargs returns `{"errors": {"json": ...}}` by +default. Override this to produce the required format: + +```python +# Format: {"error": {"code": "not_found", "message": "Machine 'foo' not found"}} +``` + +Error codes: `validation_error` (400/422), `unauthorized` (401), `forbidden` (403), +`not_found` (404), `conflict` (409), `internal_error` (500). + +### 4.5 Pagination (`pagination.py`) + +**Cursor-based** (for unbounded lists): +- Cursor encodes the last-seen primary key ID as base64 +- Forward pagination only (no `previous` cursor in v1 — simplifies implementation) +- Response envelope: `{"items": [...], "cursor": {"next": "...", "previous": null}}` +- Helper: `cursor_paginate(query, id_column, cursor_str, limit)` → `(items, next_cursor)` +- Wrap cursor decoding in try/except; return 400 on malformed cursors + +**Offset-based** (for bounded lists): +- Same envelope shape for consistency: `{"items": [...], "cursor": {"next": null, "previous": null}}` +- Include `"total"` field alongside `cursor` for bounded lists where the total is cheap to compute + +**Note**: Backward cursor pagination (`previous` cursor) is deferred to a later iteration. +The `previous` field is always present in responses but set to `null` in v1. This is a +deliberate simplification; the envelope structure is forward-compatible with adding it later. + +### 4.6 ETag Support (`etag.py`) + +- Compute ETags from response data hash (MD5 of JSON-serialized response) +- Use weak ETags: `W/""` +- Check `If-None-Match` header; return 304 if match +- Parse comma-separated ETags per RFC 7232 +- Apply primarily to single-resource GET endpoints (detail views) +- For list endpoints: skip ETags initially (the data changes frequently and computing + the full response just to check the ETag defeats the purpose) + +### 4.7 Dynamic Marshmallow Schemas + +The key challenge: LNT models are generated dynamically per test suite, with different +columns depending on the suite's schema. Marshmallow schemas for flask-smorest must be +known at decoration time for OpenAPI generation. + +**Solution**: Use a two-layer approach: +1. **Static base schemas** with known fields (uuid, name, start_time, etc.) used for + flask-smorest decorators and OpenAPI documentation +2. **Dynamic fields** serialized into a `fields` or `parameters` dict (type: `Dict`) + in the response — this captures the test-suite-specific fields without needing + per-suite schema classes +3. Cache dynamically-generated schema subclasses per test suite for internal use + +This means the OpenAPI spec shows `fields: object` for dynamic portions, which is less +precise but correct and maintainable. + +--- + +## 5. Endpoint Plans + +### 5.1 Discovery (`GET /api/v5/`) + +Returns list of available test suites with links: +```json +{ + "test_suites": [ + { + "name": "nts", + "links": { + "machines": "/api/v5/nts/machines", + "orders": "/api/v5/nts/orders", + "runs": "/api/v5/nts/runs", + "tests": "/api/v5/nts/tests", + "regressions": "/api/v5/nts/regressions", + "field_changes": "/api/v5/nts/field-changes", + "query": "/api/v5/nts/query" + } + } + ] +} +``` + +Enumerate via `app.instance.get_database("default").testsuite.keys()`. +Auth: no auth required (public). + +### 5.2 Machines + +**Endpoints:** +``` +GET /api/v5/{ts}/machines — List (offset-paginated, filterable) +POST /api/v5/{ts}/machines — Create +GET /api/v5/{ts}/machines/{machine_name} — Detail +PATCH /api/v5/{ts}/machines/{machine_name} — Update (including rename) +DELETE /api/v5/{ts}/machines/{machine_name} — Delete (cascading) +GET /api/v5/{ts}/machines/{machine_name}/runs — List runs (cursor-paginated) +``` + +**Key design decisions:** +- Machine name as URL key. Use `` (not ``). Names with + slashes must be percent-encoded by clients. Document this. +- Machine name is NOT unique in DB. On lookup: 0 results → 404, 1 result → return it, + >1 results → 409 Conflict with message. +- On POST: check uniqueness before insert. Catch `IntegrityError` on commit as fallback + for race conditions. Consider adding a DB unique constraint via migration. +- On PATCH with name change: check new name uniqueness. Response includes new URL in + `Location` header. +- On DELETE: chunked deletion (batches of 50-100 runs) to avoid OOM/timeout. + **Important**: `ChangeIgnore` rows have an FK to `FieldChange` but NO cascade configured. + On Postgres, deleting FieldChanges (via machine cascade) will fail with FK violations + unless ChangeIgnore rows are deleted first. This is a pre-existing bug in v4. The v5 + delete code must explicitly delete ChangeIgnore rows for the machine's FieldChanges + before the cascade delete runs. +- Auth: read=GET, manage=POST/PATCH/DELETE. + +**Filters** (on list): `name_contains=`, `name_prefix=` +**Filters** (on runs): `after=`, `before=` (ISO datetime), `sort=-start_time` + +### 5.3 Orders + +**Endpoints:** +``` +GET /api/v5/{ts}/orders — List (cursor-paginated, filterable) +POST /api/v5/{ts}/orders — Create with metadata +GET /api/v5/{ts}/orders/{order_value} — Detail (includes prev/next) +PATCH /api/v5/{ts}/orders/{order_value} — Update metadata +``` + +**Key design decisions:** +- `order_value` is the primary order field value (e.g., a revision number, git SHA, etc.) +- For multi-field orders: additional query params disambiguate. 409 if ambiguous. +- Order detail includes `previous_order` and `next_order` references (field values + links) +- `after`/`before` filtering: use Order.id comparison in SQL (Order IDs approximate + insertion order, which correlates with revision order for most deployments). For + correctness, post-filter in Python using `convert_revision()`. Cap the query with + a SQL LIMIT as safety net. +- No DELETE (return 405). +- Order metadata storage: if the Order model lacks a `parameters_data` column, the + PATCH endpoint is deferred until a migration adds one. For v1, POST creates orders + with field values only. +- Auth: read=GET, submit=POST, manage=PATCH. + +### 5.4 Runs + +**Endpoints:** +``` +GET /api/v5/{ts}/runs — List (cursor-paginated, filterable) +POST /api/v5/{ts}/runs — Submit (generates UUID, returns it) +GET /api/v5/{ts}/runs/{uuid} — Detail +DELETE /api/v5/{ts}/runs/{uuid} — Delete +``` + +**Key design decisions:** +- UUID generated server-side in `_getOrCreateRun()` (new `uuid` column on Run). + **Important**: The UUID must be set right after constructing the Run object (around + line 1017 of `testsuitedb.py`), BEFORE `import_and_report()` calls `session.commit()` + at ImportData.py line 147. The import pipeline does multiple commits during a single + request, so setting the UUID after the function returns would be too late. +- Submission reuses existing `ImportData.import_from_string()` pipeline for backward + compatibility with `lnt submit` tool. This function requires `current_app.old_config` + as its `config` argument (it uses `config.tempDir`, `config.databases`, etc.) and + `g.db_name` must be set to `"default"` (done by middleware). +- `machine=` filter accepts **machine name** (string), NOT machine ID. + Internally: look up machine by name → filter by machine.id. Handle ambiguous names. +- Response NEVER exposes internal IDs. Use `machine_name` instead of `machine_id`, + `uuid` instead of `id`. +- Run deletion: `session.delete(run)` with cascading. For runs with many samples, + consider batched sample deletion. +- For `merge='replace'` strategy: new run gets a NEW UUID. +- Auth: read=GET, submit=POST, manage=DELETE. + +**Filters**: `machine=` (name), `order=` (exact match on primary order field value), `after=`, `before=` (ISO datetime), `sort=-start_time` + +### 5.5 Tests + +**Endpoints:** +``` +GET /api/v5/{ts}/tests — List (cursor-paginated, filterable) +GET /api/v5/{ts}/tests/{test_name} — Detail +``` + +**Key design decisions:** +- Read-only. Tests created implicitly via run submission. +- Use `` converter for test names with slashes +- Filter: `name_contains=`, `name_prefix=` +- Escape `%` and `_` in user-supplied LIKE patterns to prevent pattern injection +- Auth: read only. + +### 5.6 Samples + +**Endpoints:** +``` +GET /api/v5/{ts}/runs/{uuid}/samples — All samples (cursor-paginated) +GET /api/v5/{ts}/runs/{uuid}/samples?has_profile=true — Filter to profiled samples +GET /api/v5/{ts}/runs/{uuid}/tests/{test_name}/samples — Samples for specific test +``` + +**Key design decisions:** +- Always accessed through parent run (no independent identifier) +- Serialization: `test_name`, `has_profile`, `metrics: {field_name: value, ...}` +- Dynamic metric fields serialized into a `metrics` dict +- No internal IDs exposed +- Auth: read only. + +### 5.7 Profiles + +**Endpoints:** +``` +GET /api/v5/{ts}/runs/{uuid}/tests/{test_name}/profile — Metadata + counters +GET /api/v5/{ts}/runs/{uuid}/tests/{test_name}/profile/functions — Function list +GET /api/v5/{ts}/runs/{uuid}/tests/{test_name}/profile/functions/{fn_name} — Disassembly +``` + +**Key design decisions:** +- Find sample for run+test that has a profile attached +- Always load profile from DISK (not the truncated DB `counters` column) + via `sample.profile.load(profileDir)` +- Use existing methods: `getTopLevelCounters()`, `getFunctions()`, `getCodeForFunction()` +- Handle missing profile files gracefully (404 with clear message) +- Function list: not paginated (typically small). Document that very large profiles + may produce large responses. +- Use `` for C++ mangled function names +- Auth: read only. + +### 5.8 Regressions + +**Endpoints:** +``` +GET /api/v5/{ts}/regressions — List (cursor-paginated) +POST /api/v5/{ts}/regressions — Create from field changes +GET /api/v5/{ts}/regressions/{uuid} — Detail with indicators +PATCH /api/v5/{ts}/regressions/{uuid} — Update +DELETE /api/v5/{ts}/regressions/{uuid} — Delete +POST /api/v5/{ts}/regressions/{uuid}/merge — Merge +POST /api/v5/{ts}/regressions/{uuid}/split — Split +GET /api/v5/{ts}/regressions/{uuid}/indicators — List indicators +POST /api/v5/{ts}/regressions/{uuid}/indicators — Add indicator +DELETE /api/v5/{ts}/regressions/{uuid}/indicators/{fc_uuid} — Remove indicator +``` + +**Key design decisions:** +- Identified by **UUID** (NOT integer ID). Requires migration. +- State mapping: API strings ↔ DB integers: + `detected`↔0, `staged`↔1, `active`↔10, `not_to_be_fixed`↔20, + `ignored`↔21, `fixed`↔22, `detected_fixed`↔23 +- State transitions unconstrained. + +**Detail response** includes embedded indicators: +```json +{ + "uuid": "...", "title": "...", "bug": "...", "state": "active", + "indicators": [ + { + "field_change_uuid": "...", + "test_name": "...", "machine_name": "...", "field_name": "...", + "old_value": 0.5, "new_value": 0.8, + "start_order": "154000", "end_order": "154331", + "run_uuid": "..." + } + ] +} +``` + +**Merge**: target absorbs sources. Sources marked as IGNORED. Indicators moved to target. +Deduplicate indicators (don't link same field change twice). Validate: cannot merge into self. +Request body uses UUIDs: `{"source_regression_uuids": ["...", "..."]}`. + +**Split**: move specified field changes to a new regression. Validate: cannot split ALL +indicators (would leave source empty). Request body uses UUIDs: +`{"field_change_uuids": ["...", "..."]}`. + +**Filtering**: `state=` (multiple values), `machine=` (name, requires JOIN through +indicators→field_changes→machines), `test=` (name, similar JOIN). + +Auth: read=GET, triage=POST/PATCH/DELETE/merge/split/indicators. + +### 5.9 Field Changes + +**Endpoints:** +``` +GET /api/v5/{ts}/field-changes — List unassigned (cursor-paginated) +POST /api/v5/{ts}/field-changes — Create a field change +POST /api/v5/{ts}/field-changes/{uuid}/ignore — Ignore +DELETE /api/v5/{ts}/field-changes/{uuid}/ignore — Un-ignore +``` + +**Key design decisions:** +- Identified by **UUID** (NOT integer ID). Requires migration. +- "Unassigned" = no RegressionIndicator AND no ChangeIgnore (LEFT JOIN + IS NULL pattern + from regression_views.py line 77-85) +- Filters: `machine=`, `test=`, `field=` +- Ignore: create ChangeIgnore row. 409 if already ignored. +- Un-ignore: delete ChangeIgnore row. 404 if not ignored. +- Auth: read=GET, triage=POST (ignore/un-ignore), submit=POST (create). + +**POST /field-changes (create):** +- Allows creating a field change programmatically (e.g., from external analysis tools) +- Request body fields (all resolved by name, not internal ID): + - `machine` (string, required) — machine name + - `test` (string, required) — test name + - `metric` (string, required) — metric name as defined in the test suite schema + - `old_value` (float, required) — previous value + - `new_value` (float, required) — new value + - `start_order` (string, required) — primary order field value for the start of the change + - `end_order` (string, required) — primary order field value for the end of the change + - `run_uuid` (string, optional) — UUID of the associated run +- Returns 404 if machine, test, metric, start_order, end_order, or run_uuid cannot be resolved +- Server generates a UUID for the new field change +- Returns 201 with the serialized field change on success +- Auth: `submit` scope required + +### 5.10 Time Series + +**Endpoint:** +``` +GET /api/v5/{ts}/series?machine={name}&test={name}&field={name}&after={order}&before={order}&limit={n} +``` + +**Key design decisions:** +- `machine`, `test`, `field` are all REQUIRED (by name, not ID) +- Field name → Sample column resolution via `ts.sample_fields` name→column mapping +- Core query: `SELECT field.column, order.*, run.* FROM Sample JOIN Run JOIN Order + WHERE machine_id=X AND test_id=Y AND field IS NOT NULL` +- Filter out failing tests if the field has a status_field +- Ordering: fetch with SQL ORDER BY on Order.id, then post-sort in Python using + `convert_revision()` for correctness. Apply `after`/`before` filters in Python. + Cap SQL query at 10,000 rows as safety limit. +- Cursor: encode the last order's field values. On next request, use to resume. +- Response per data point: `{value, order: {field_name: value}, run_uuid, timestamp}` +- Auth: read only. + +### 5.11 Schema and Fields + +Schema definitions and metric field metadata are provided through the test-suites +endpoint rather than as standalone endpoints: + +``` +GET /api/v5/test-suites/{name} — Returns schema + fields in the response body +``` + +The `GET /api/v5/test-suites/{name}` response includes a `schema` object (produced by +`ts.test_suite.__json__()`) containing `machine_fields`, `run_fields`, and `metrics`. +Each metric entry includes: `name`, `type`, `display_name`, `unit`, `unit_abbrev`, +`bigger_is_better`, `ignore_same_hash`. + +There are no separate `/fields` or `/schema` endpoints. Clients that need field +metadata should call `GET /api/v5/test-suites/{name}` and read the `schema` object. + +Auth: read only (no auth required for test-suite detail). + +### 5.12 Admin (API Keys) + +**Endpoints:** +``` +GET /api/v5/admin/api-keys — List keys (admin) +POST /api/v5/admin/api-keys — Create key (admin), returns raw token ONCE +DELETE /api/v5/admin/api-keys/{prefix} — Revoke key by prefix (admin) +``` + +- Keys identified by their `prefix` (first 8 chars of the token, stored in DB) in URLs. + This avoids exposing internal integer IDs per R2. +- POST returns `{"key": "raw-token-value", "prefix": "abc12345", "scope": "read"}` + The raw token is shown ONCE and never stored in plaintext. +- List shows: prefix, name, scope, created_at, last_used_at, is_active (never the hash) +- DELETE sets is_active=False (soft delete for audit trail) +- Auth: admin scope required for all. + +--- + +## 6. Testing Strategy + +### 6.1 Framework + +Use **pytest** for v5 API test logic, running against **PostgreSQL** (not SQLite). +Each test file includes a lit `RUN` line that uses `with_postgres.sh` to set up a +Postgres instance, then invokes pytest. This combines: +- Postgres as the real production database engine (catches type coercion, FK enforcement, + string comparison, and transaction isolation differences that SQLite would mask) +- lit integration with the existing test infrastructure +- pytest's ergonomics (fixtures, parametrize, clear assertions) + +Example test file structure: +```python +# RUN: %{shared_inputs}/with_postgres.sh %s + +import pytest +# ... normal pytest tests using Flask test client against Postgres ... +``` + +### 6.2 Fixtures (`tests/server/api/v5/conftest.py`) + +```python +@pytest.fixture(scope="session") +def app(): + """Create Flask app with test instance against Postgres (set up by with_postgres.sh).""" + +@pytest.fixture +def client(app): + """Flask test client.""" + return app.test_client() + +@pytest.fixture +def db_session(app): + """Direct DB session for test setup/assertions. Rolls back after each test.""" + +@pytest.fixture +def admin_headers(app): + """Auth headers with admin scope for test requests.""" + +@pytest.fixture +def read_headers(app): + """Auth headers with read scope.""" +``` + +Use `scope="function"` for db_session to ensure test isolation. For the client fixture, +consider wrapping each test in a transaction savepoint that gets rolled back. + +### 6.3 Test Files + +``` +tests/server/api/v5/ + conftest.py + test_discovery.py + test_machines.py + test_orders.py + test_runs.py + test_tests.py + test_samples.py + test_profiles.py + test_regressions.py + test_field_changes.py + test_series.py + test_admin.py + test_auth.py + test_errors.py + test_pagination.py + test_etag.py +``` + +### 6.4 Coverage Requirements + +Each endpoint must test: +- Happy path (200/201/204 responses) +- Not found (404) +- Auth required (401 without token) +- Insufficient scope (403 with wrong scope) +- Validation errors (400/422 for bad input) +- Conflict cases (409 for duplicates) +- Pagination (cursor navigation, limit parameter) +- Filtering (each filter parameter) +- ETag (on detail endpoints) + +--- + +## 7. Implementation Phases + +### Phase 1: Foundation +1. Add dependencies to pyproject.toml +2. Create package structure (`lnt/server/api/v5/`) +3. Write migration `upgrade_18_to_19.py` (UUID columns + APIKey table) +4. Update model definitions in `testsuitedb.py` (UUID columns) +5. Implement `create_v5_api()` and register in `app.py` +6. Implement middleware (testsuite resolution, CORS, session lifecycle) +7. Implement auth (APIKey model, Bearer validation, scope decorators) +8. Implement error handling (blueprint-scoped) +9. Implement pagination utilities (cursor + offset) +10. Implement ETag utilities +11. Set up pytest infrastructure (conftest.py, fixtures) +12. Implement discovery endpoint +13. Implement admin/API key endpoints +14. Write tests for auth, errors, pagination, discovery, admin + +### Phase 2: Core Read Endpoints +15. Machine list and detail + tests +16. Order list and detail + tests +17. Test list and detail + tests + +### Phase 3: Write Endpoints +18. Run submission (POST /runs) + tests +19. Run detail and delete + tests +20. Machine create, update, delete + tests +21. Order create and update + tests + +### Phase 4: Samples and Profiles +22. Sample listing endpoints + tests +23. Profile endpoints + tests + +### Phase 5: Regressions and Field Changes +24. Regression CRUD + tests +25. Regression merge and split + tests +26. Regression indicators + tests +27. Field change triage + tests + +### Phase 6: Time Series +28. Series endpoint + tests + +### Phase 7: Polish +29. OpenAPI spec review and validation +30. ETag support on all detail endpoints +31. End-to-end integration tests +32. Documentation review + +--- + +## 8. Key Risks and Mitigations + +| Risk | Mitigation | +|------|------------| +| flask-smorest incompatible with SQLAlchemy 1.3.24 | **Verified: compatible.** flask-smorest 0.46.2 works with SQLAlchemy 1.3.24 | +| flask-smorest conflicts with Flask-RESTful | **Verified: coexists.** Both frameworks work on the same app without conflicts | +| Dynamic schemas vs OpenAPI generation | Use Dict fields for dynamic portions. Accept less precise OpenAPI docs | +| Large machine deletion timeouts | Chunked deletion (50-100 runs per batch) | +| Migration on large databases | Batched UUID backfill (1000 rows per batch) | +| Machine name ambiguity (duplicates) | 409 Conflict response with guidance to merge/rename | +| Order after/before filtering correctness | Python post-filtering with convert_revision() | +| Test names with slashes in URLs | converter; document client must not end names with /profile or /samples | + +--- + +## 9. Files Modified in Existing Codebase + +| File | Change | +|------|--------| +| `pyproject.toml` | Add flask-smorest dependency | +| `lnt/server/ui/app.py` | Add `create_v5_api(app)` call after line 153 | +| `lnt/server/db/testsuitedb.py` | Add UUID columns to Run, FieldChange, Regression classes | +| `lnt/server/db/testsuitedb.py` | Set UUID in `_getOrCreateRun()` | +| `lnt/server/db/regression.py` | Set UUID in `new_regression()` | +| `lnt/server/db/fieldchange.py` | Set UUID when creating FieldChange objects (in `regenerate_fieldchanges_for_run()`) | +| `lnt/server/db/migrations/` | Add `upgrade_18_to_19.py` | +| `lnt/server/db/migrate.py` | Bump expected schema version | diff --git a/lnt/server/api/__init__.py b/lnt/server/api/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/lnt/server/api/v5/__init__.py b/lnt/server/api/v5/__init__.py new file mode 100644 index 000000000..b6e0210cd --- /dev/null +++ b/lnt/server/api/v5/__init__.py @@ -0,0 +1,35 @@ +"""LNT v5 REST API factory. + +Creates and configures the flask-smorest Api instance, registers middleware, +and hooks up all endpoint blueprints. +""" + +from flask_smorest import Api as SmorestApi + + +def create_v5_api(app): + """Create and register the v5 REST API on the given Flask app. + + Returns the flask-smorest Api instance. + """ + app.config.update({ + "API_TITLE": "LNT API", + "API_VERSION": "v5", + "OPENAPI_VERSION": "3.0.3", + "OPENAPI_URL_PREFIX": "/api/v5/openapi", + "OPENAPI_JSON_PATH": "openapi.json", + "OPENAPI_SWAGGER_UI_PATH": "/swagger-ui", + "OPENAPI_SWAGGER_UI_URL": "https://cdn.jsdelivr.net/npm/swagger-ui-dist/", + }) + smorest_api = SmorestApi(app) + + from .middleware import register_middleware + register_middleware(app) + + from .errors import register_error_handlers + register_error_handlers(smorest_api, app) + + from .endpoints import register_all_endpoints + register_all_endpoints(smorest_api) + + return smorest_api diff --git a/lnt/server/api/v5/auth.py b/lnt/server/api/v5/auth.py new file mode 100644 index 000000000..2a955d411 --- /dev/null +++ b/lnt/server/api/v5/auth.py @@ -0,0 +1,163 @@ +"""v5 API authentication: APIKey model, Bearer token validation, scope +decorators. + +Scope hierarchy (linear, each level includes all below): + read (0) < submit (1) < triage (2) < manage (3) < admin (4) +""" + +import datetime +import hashlib +import hmac +import functools + +from flask import current_app, g, request +from sqlalchemy import Column, String, Integer, Boolean, DateTime +from sqlalchemy.ext.declarative import declarative_base +import sqlalchemy.exc + +# Separate declarative base so the APIKey table does not contaminate +# per-testsuite metadata. +APIKeyBase = declarative_base() + + +class APIKey(APIKeyBase): + """API key stored in the global (non-per-testsuite) database.""" + + __tablename__ = 'APIKey' + + id = Column("ID", Integer, primary_key=True) + name = Column("Name", String(256), nullable=False) + key_prefix = Column("KeyPrefix", String(8), nullable=False) + key_hash = Column("KeyHash", String(64), nullable=False, unique=True, + index=True) + scope = Column("Scope", String(32), nullable=False) + created_at = Column("CreatedAt", DateTime, nullable=False) + last_used_at = Column("LastUsedAt", DateTime, nullable=True) + is_active = Column("IsActive", Boolean, nullable=False, default=True) + + +# --------------------------------------------------------------------------- +# Scope hierarchy +# --------------------------------------------------------------------------- + +SCOPE_LEVELS = { + 'read': 0, + 'submit': 1, + 'triage': 2, + 'manage': 3, + 'admin': 4, +} + + +def _get_scope_level(scope_name): + """Return the integer level for a scope name.""" + return SCOPE_LEVELS.get(scope_name, -1) + + +def _hash_token(token): + """SHA-256 hash of a raw token string.""" + return hashlib.sha256(token.encode('utf-8')).hexdigest() + + +def _resolve_bearer_token(): + """Extract and validate the Bearer token from the Authorization header. + + Returns a tuple of (scope_name, api_key_or_None). If no token is + provided (no Authorization header, or non-Bearer scheme), returns + (None, None) so the caller can allow unauthenticated reads. + + If a Bearer token IS provided but is invalid or revoked, aborts + with 401 immediately — an explicitly-presented credential that + fails validation must never be silently downgraded to + unauthenticated access. + """ + auth_header = request.headers.get('Authorization', '') + if not auth_header.startswith('Bearer '): + return None, None + + token = auth_header[len('Bearer '):] + if not token: + from flask import abort + abort(401) + + # Check bootstrap token from lnt.cfg first + legacy_token = getattr(current_app.old_config, 'api_auth_token', None) + if legacy_token and hmac.compare_digest(token, legacy_token): + return 'admin', None + + # Look up hashed token in the APIKey table + session = getattr(g, 'db_session', None) + if session is None: + from flask import abort + abort(401) + + key_hash = _hash_token(token) + try: + api_key = session.query(APIKey).filter( + APIKey.key_hash == key_hash, + APIKey.is_active.is_(True), + ).first() + except (sqlalchemy.exc.OperationalError, sqlalchemy.exc.ProgrammingError): + # Table may not exist yet (pre-migration) + return None, None + + if api_key is None: + from flask import abort + abort(401) + + # Update last_used_at (best effort) + try: + api_key.last_used_at = datetime.datetime.utcnow() + except Exception: + pass + + return api_key.scope, api_key + + +def get_current_auth(): + """Return (scope_name, api_key_or_None) for the current request. + + Caches the result on ``g`` for the duration of the request. + """ + if hasattr(g, '_v5_auth'): + return g._v5_auth + result = _resolve_bearer_token() + g._v5_auth = result + return result + + +def require_scope(scope_name): + """Decorator that enforces the given scope on a view function. + + If the endpoint requires only ``read`` scope and the deployment + has not set ``require_auth_for_reads`` in lnt.cfg, unauthenticated + requests are allowed (matching v4 behaviour). + """ + required_level = _get_scope_level(scope_name) + + def decorator(fn): + @functools.wraps(fn) + def wrapper(*args, **kwargs): + granted_scope, _api_key = get_current_auth() + + if granted_scope is None: + # No token provided + if required_level <= SCOPE_LEVELS['read']: + # Allow unauthenticated reads unless the deployment + # requires authentication for reads. + require_auth = getattr( + current_app.old_config, + 'require_auth_for_reads', False) + if not require_auth: + return fn(*args, **kwargs) + from flask import abort + abort(401) + + granted_level = _get_scope_level(granted_scope) + if granted_level < required_level: + from flask import abort + abort(403) + + return fn(*args, **kwargs) + return wrapper + return decorator diff --git a/lnt/server/api/v5/endpoints/__init__.py b/lnt/server/api/v5/endpoints/__init__.py new file mode 100644 index 000000000..3d02d08c9 --- /dev/null +++ b/lnt/server/api/v5/endpoints/__init__.py @@ -0,0 +1,53 @@ +"""Endpoint registration for the v5 API. + +``register_all_endpoints()`` imports and registers all endpoint blueprints. +Missing modules are handled gracefully (with a warning) so the app works +during incremental development. +""" + +import logging + +logger = logging.getLogger(__name__) + +# All endpoint modules that should be registered. Each entry is the +# sub-module name relative to ``lnt.server.api.v5.endpoints``. +_ENDPOINT_MODULES = [ + 'discovery', + 'test_suites', + 'machines', + 'orders', + 'runs', + 'tests', + 'samples', + 'profiles', + 'regressions', + 'field_changes', + 'query', + 'admin', +] + + +def register_all_endpoints(smorest_api): + """Import and register every endpoint blueprint with the Api instance. + + Endpoint modules must expose a ``blp`` attribute which is a + ``flask_smorest.Blueprint`` instance. + """ + import importlib + + for module_name in _ENDPOINT_MODULES: + fqn = 'lnt.server.api.v5.endpoints.%s' % module_name + try: + mod = importlib.import_module(fqn) + blp = getattr(mod, 'blp', None) + if blp is not None: + smorest_api.register_blueprint(blp) + else: + logger.debug("Module %s has no 'blp' attribute, skipping.", + fqn) + except ImportError: + logger.debug("Endpoint module %s not yet implemented, skipping.", + fqn) + except Exception: + logger.warning("Failed to register endpoint module %s:", + fqn, exc_info=True) diff --git a/lnt/server/api/v5/endpoints/admin.py b/lnt/server/api/v5/endpoints/admin.py new file mode 100644 index 000000000..18ce1e37f --- /dev/null +++ b/lnt/server/api/v5/endpoints/admin.py @@ -0,0 +1,127 @@ +"""Admin endpoints: API key management. + +GET /api/v5/admin/api-keys -- List all API keys (admin scope) +POST /api/v5/admin/api-keys -- Create a new API key (admin scope) +DELETE /api/v5/admin/api-keys/{prefix} -- Revoke a key by prefix (admin scope) + +Admin endpoints live OUTSIDE the {testsuite} namespace. The middleware opens +a DB session for auth validation but does NOT resolve a test suite. +""" + +import datetime +import secrets + +from flask import g +from flask.views import MethodView +from flask_smorest import Blueprint + +from ..auth import APIKey, require_scope, _hash_token +from ..errors import reject_unknown_params +from ..schemas.admin import ( + APIKeyCreateRequestSchema, + APIKeyCreateResponseSchema, + APIKeyListResponseSchema, +) + +blp = Blueprint( + 'Admin', + __name__, + url_prefix='/api/v5/admin', + description='Create, list, and revoke API keys (scopes: read, submit, triage, manage, admin)', +) + + +@blp.route('/api-keys') +class APIKeyCollection(MethodView): + """List and create API keys.""" + + @require_scope('admin') + @blp.response(200, APIKeyListResponseSchema) + def get(self): + """List all API keys. + + Returns metadata for every key (prefix, name, scope, timestamps, + and active status). The raw token is never included. + """ + reject_unknown_params(set()) + session = g.db_session + keys = session.query(APIKey).order_by(APIKey.id).all() + + items = [] + for k in keys: + items.append({ + 'prefix': k.key_prefix, + 'name': k.name, + 'scope': k.scope, + 'created_at': k.created_at, + 'last_used_at': k.last_used_at, + 'is_active': k.is_active, + }) + + return {'items': items} + + @require_scope('admin') + @blp.arguments(APIKeyCreateRequestSchema) + @blp.response(201, APIKeyCreateResponseSchema) + def post(self, payload): + """Create a new API key. + + Returns the raw token exactly once. Store it securely -- it + cannot be retrieved again. + """ + name = payload['name'] + scope = payload['scope'] + + # Generate a cryptographically random token + raw_token = secrets.token_hex(32) # 64-char hex string + prefix = raw_token[:8] + key_hash = _hash_token(raw_token) + + api_key = APIKey( + name=name, + key_prefix=prefix, + key_hash=key_hash, + scope=scope, + created_at=datetime.datetime.utcnow(), + is_active=True, + ) + + session = g.db_session + session.add(api_key) + session.flush() + + return { + 'key': raw_token, + 'prefix': prefix, + 'scope': scope, + } + + +@blp.route('/api-keys/') +class APIKeyByPrefix(MethodView): + """Revoke a single API key identified by its prefix.""" + + @require_scope('admin') + @blp.response(204) + def delete(self, prefix): + """Revoke an API key by its prefix. + + The key is deactivated rather than deleted, preserving the + audit trail. + """ + session = g.db_session + api_key = session.query(APIKey).filter( + APIKey.key_prefix == prefix, + ).first() + + if api_key is None: + from ..errors import abort_with_error + abort_with_error( + 404, + "API key with prefix '%s' not found" % prefix, + ) + + api_key.is_active = False + session.flush() + + return '' diff --git a/lnt/server/api/v5/endpoints/discovery.py b/lnt/server/api/v5/endpoints/discovery.py new file mode 100644 index 000000000..3c277d07c --- /dev/null +++ b/lnt/server/api/v5/endpoints/discovery.py @@ -0,0 +1,52 @@ +"""Discovery endpoint: GET /api/v5/ + +Returns a list of available test suites with links to their resources. +No authentication required. +""" + +from flask import g +from flask.views import MethodView +from flask_smorest import Blueprint + +from ..errors import reject_unknown_params +from ..schemas.common import DiscoveryResponseSchema +from .test_suites import _suite_links + +blp = Blueprint( + 'Discovery', + __name__, + url_prefix='/api/v5', + description='Discover available test suites and their resource URLs', +) + + +@blp.route('/') +class Discovery(MethodView): + """Discover available test suites.""" + + @blp.response(200, DiscoveryResponseSchema) + def get(self): + """List all available test suites with links. + + No authentication required. + """ + reject_unknown_params(set()) + db = getattr(g, 'db', None) + if db is None: + return {'test_suites': []} + + suites = [] + for name in sorted(db.testsuite.keys()): + suites.append({ + 'name': name, + 'links': _suite_links(name), + }) + + return { + 'test_suites': suites, + 'links': { + 'openapi': '/api/v5/openapi/openapi.json', + 'swagger_ui': '/api/v5/openapi/swagger-ui', + 'test_suites': '/api/v5/test-suites', + }, + } diff --git a/lnt/server/api/v5/endpoints/field_changes.py b/lnt/server/api/v5/endpoints/field_changes.py new file mode 100644 index 000000000..5786f6678 --- /dev/null +++ b/lnt/server/api/v5/endpoints/field_changes.py @@ -0,0 +1,245 @@ +"""Field change endpoints for the v5 API. + +GET /api/v5/{ts}/field-changes -- List unassigned +POST /api/v5/{ts}/field-changes -- Create a field change +POST /api/v5/{ts}/field-changes/{uuid}/ignore -- Ignore a field change +DELETE /api/v5/{ts}/field-changes/{uuid}/ignore -- Un-ignore a field change +""" + +import uuid as uuid_module + +from flask import g, jsonify, make_response +from flask.views import MethodView +from flask_smorest import Blueprint + +from ..auth import require_scope +from ..errors import abort_with_error, reject_unknown_params +from ..helpers import ( + lookup_fieldchange, + lookup_machine, + resolve_metric, + serialize_fieldchange, +) +from ..pagination import ( + cursor_paginate, + make_paginated_response, +) +from ..schemas.common import FieldChangeIgnoreResponseSchema +from ..schemas.regressions import ( + FieldChangeCreateSchema, + FieldChangeListQuerySchema, + FieldChangeResponseSchema, + PaginatedFieldChangeResponseSchema, +) + +blp = Blueprint( + 'Field Changes', + __name__, + url_prefix='/api/v5/', + description='List, create, and triage significant metric changes between orders', +) + + +# --------------------------------------------------------------------------- +# Helpers +# --------------------------------------------------------------------------- + +def _serialize_fieldchange(fc): + """Serialize a FieldChange for the API response.""" + result = serialize_fieldchange(fc) + result['uuid'] = fc.uuid + return result + + +# --------------------------------------------------------------------------- +# Field Changes List (unassigned) +# --------------------------------------------------------------------------- + +@blp.route('/field-changes') +class FieldChangeList(MethodView): + """List and create field changes.""" + + @require_scope('read') + @blp.arguments(FieldChangeListQuerySchema, location="query") + @blp.response(200, PaginatedFieldChangeResponseSchema) + def get(self, query_args, testsuite): + """List unassigned field changes (cursor-paginated, filterable). + + Returns field changes that have not been assigned to a regression + and have not been ignored. + """ + reject_unknown_params({'machine', 'test', 'metric', 'cursor', 'limit'}) + ts = g.ts + session = g.db_session + + # Build query: unassigned field changes + # LEFT JOIN ChangeIgnore, filter IS NULL + # LEFT JOIN RegressionIndicator, filter IS NULL + query = session.query(ts.FieldChange) \ + .outerjoin(ts.ChangeIgnore) \ + .filter(ts.ChangeIgnore.id.is_(None)) \ + .outerjoin(ts.RegressionIndicator) \ + .filter(ts.RegressionIndicator.id.is_(None)) + + # Filter by machine name + machine_name = query_args.get('machine') + if machine_name: + query = query.join( + ts.Machine, + ts.FieldChange.machine_id == ts.Machine.id + ).filter(ts.Machine.name == machine_name) + + # Filter by test name + test_name = query_args.get('test') + if test_name: + query = query.join( + ts.Test, + ts.FieldChange.test_id == ts.Test.id + ).filter(ts.Test.name == test_name) + + # Filter by metric name + field_name = query_args.get('metric') + if field_name: + matching_field = resolve_metric(ts, field_name) + query = query.filter( + ts.FieldChange.field_id == matching_field.id) + + # Order by descending ID (most recent first) via cursor_paginate. + cursor_str = query_args.get('cursor') + limit = query_args['limit'] + items, next_cursor = cursor_paginate( + query, ts.FieldChange.id, cursor_str, limit, descending=True) + + serialized = [_serialize_fieldchange(fc) for fc in items] + return jsonify(make_paginated_response(serialized, next_cursor)) + + @require_scope('submit') + @blp.arguments(FieldChangeCreateSchema) + @blp.response(201, FieldChangeResponseSchema) + def post(self, body, testsuite): + """Create a field change. + + References machine, test, metric, and orders by name. + """ + ts = g.ts + session = g.db_session + + # Resolve machine + machine = lookup_machine(session, ts, body['machine']) + + # Resolve test + test = session.query(ts.Test).filter( + ts.Test.name == body['test'] + ).first() + if test is None: + abort_with_error( + 404, + "Test '%s' not found" % body['test']) + + # Resolve field + matching_field = resolve_metric(ts, body['metric']) + + # Resolve start_order and end_order via primary order field + primary_field = ts.order_fields[0] + + start_order = session.query(ts.Order).filter( + primary_field.column == body['start_order'] + ).first() + if start_order is None: + abort_with_error( + 404, + "Start order '%s' not found" % body['start_order']) + + end_order = session.query(ts.Order).filter( + primary_field.column == body['end_order'] + ).first() + if end_order is None: + abort_with_error( + 404, + "End order '%s' not found" % body['end_order']) + + # Resolve optional run_uuid + run = None + if body.get('run_uuid'): + run = session.query(ts.Run).filter( + ts.Run.uuid == body['run_uuid'] + ).first() + if run is None: + abort_with_error( + 404, + "Run '%s' not found" % body['run_uuid']) + + # Create FieldChange + fc = ts.FieldChange( + start_order=start_order, + end_order=end_order, + machine=machine, + test=test, + field_id=matching_field.id, + ) + fc.uuid = str(uuid_module.uuid4()) + fc.old_value = body['old_value'] + fc.new_value = body['new_value'] + if run is not None: + fc.run = run + session.add(fc) + session.flush() + + data = _serialize_fieldchange(fc) + resp = jsonify(data) + resp.status_code = 201 + return resp + + +# --------------------------------------------------------------------------- +# Ignore / Un-ignore +# --------------------------------------------------------------------------- + +@blp.route('/field-changes//ignore') +class FieldChangeIgnore(MethodView): + """Ignore and un-ignore a field change.""" + + @require_scope('triage') + @blp.response(201, FieldChangeIgnoreResponseSchema) + def post(self, testsuite, fc_uuid): + """Ignore a field change. Returns 409 if already ignored.""" + ts = g.ts + session = g.db_session + fc = lookup_fieldchange(session, ts, fc_uuid) + + # Check if already ignored + existing = session.query(ts.ChangeIgnore).filter( + ts.ChangeIgnore.field_change_id == fc.id + ).first() + if existing: + abort_with_error( + 409, "Field change '%s' is already ignored" % fc_uuid) + + ignore = ts.ChangeIgnore(fc) + session.add(ignore) + session.flush() + + resp = jsonify({'status': 'ignored', 'field_change_uuid': fc.uuid}) + resp.status_code = 201 + return resp + + @require_scope('triage') + @blp.response(204) + def delete(self, testsuite, fc_uuid): + """Un-ignore a field change. Returns 404 if not currently ignored.""" + ts = g.ts + session = g.db_session + fc = lookup_fieldchange(session, ts, fc_uuid) + + # Find the ChangeIgnore row + ignore = session.query(ts.ChangeIgnore).filter( + ts.ChangeIgnore.field_change_id == fc.id + ).first() + if ignore is None: + abort_with_error( + 404, "Field change '%s' is not ignored" % fc_uuid) + + session.delete(ignore) + session.flush() + + return make_response('', 204) diff --git a/lnt/server/api/v5/endpoints/machines.py b/lnt/server/api/v5/endpoints/machines.py new file mode 100644 index 000000000..9da1d6eac --- /dev/null +++ b/lnt/server/api/v5/endpoints/machines.py @@ -0,0 +1,310 @@ +"""Machine endpoints for the v5 API. + +GET /api/v5/{ts}/machines -- List machines +POST /api/v5/{ts}/machines -- Create machine +GET /api/v5/{ts}/machines/{machine_name} -- Machine detail +PATCH /api/v5/{ts}/machines/{machine_name} -- Update machine +DELETE /api/v5/{ts}/machines/{machine_name} -- Delete machine +GET /api/v5/{ts}/machines/{machine_name}/runs -- List runs for machine +""" + +from flask import g, jsonify, make_response +from flask.views import MethodView +from flask_smorest import Blueprint + +from ..auth import require_scope +from ..errors import abort_with_error, reject_unknown_params +from ..etag import add_etag_to_response +from ..helpers import escape_like, lookup_machine, parse_datetime, serialize_run +from ..pagination import ( + cursor_paginate, + make_paginated_response, +) +from ..schemas.machines import ( + MachineCreateSchema, + MachineListQuerySchema, + MachineResponseSchema, + MachineRunsQuerySchema, + MachineUpdateSchema, + PaginatedMachineResponseSchema, + PaginatedMachineRunResponseSchema, +) + +blp = Blueprint( + 'Machines', + __name__, + url_prefix='/api/v5/', + description='List, create, update, and delete machines, and list their runs', +) + + +def _serialize_machine(machine): + """Serialize a Machine model instance for the API response.""" + info = {} + # Add declared machine fields + for field in machine.fields: + val = machine.get_field(field) + if val is not None: + info[field.name] = str(val) + # Add parameters blob + try: + params = machine.parameters + for k, v in params.items(): + info[k] = str(v) + except (TypeError, ValueError): + pass + return { + 'name': machine.name, + 'info': info, + } + + +@blp.route('/machines') +class MachineList(MethodView): + """List and create machines.""" + + @require_scope('read') + @blp.arguments(MachineListQuerySchema, location="query") + @blp.response(200, PaginatedMachineResponseSchema) + def get(self, query_args, testsuite): + """List machines (offset-paginated, filterable).""" + reject_unknown_params({'name_contains', 'name_prefix', 'limit', 'offset'}) + ts = g.ts + session = g.db_session + + query = session.query(ts.Machine) + + # Apply filters + name_contains = query_args.get('name_contains') + if name_contains: + escaped = escape_like(name_contains) + query = query.filter( + ts.Machine.name.like('%' + escaped + '%', escape='\\')) + + name_prefix = query_args.get('name_prefix') + if name_prefix: + escaped = escape_like(name_prefix) + query = query.filter( + ts.Machine.name.like(escaped + '%', escape='\\')) + + query = query.order_by(ts.Machine.name.asc()) + + # Offset pagination for machines (bounded list) + total = query.count() + + limit = query_args['limit'] + limit = max(1, min(limit, 500)) + + offset = query_args['offset'] + offset = max(0, offset) + + machines = query.offset(offset).limit(limit).all() + + items = [_serialize_machine(m) for m in machines] + return jsonify(make_paginated_response(items, None, total=total)) + + @require_scope('manage') + @blp.arguments(MachineCreateSchema) + @blp.response(201, MachineResponseSchema) + def post(self, body, testsuite): + """Create a new machine.""" + ts = g.ts + session = g.db_session + + name = body['name'].strip() + + # Check for existing machine with same name + existing = session.query(ts.Machine).filter( + ts.Machine.name == name + ).first() + if existing: + abort_with_error( + 409, "A machine named '%s' already exists" % name) + + machine = ts.Machine(name) + info = body.get('info') or {} + if info and isinstance(info, dict): + # Set declared fields and parameters + declared = {f.name for f in ts.machine_fields} + params = {} + for key, value in info.items(): + if key in declared: + setattr(machine, key, value) + else: + params[key] = value + machine.parameters = params + else: + machine.parameters = {} + + session.add(machine) + session.flush() + + resp = jsonify(_serialize_machine(machine)) + resp.status_code = 201 + return resp + + +@blp.route('/machines/') +class MachineDetail(MethodView): + """Machine detail, update, and delete.""" + + @require_scope('read') + @blp.response(200, MachineResponseSchema) + def get(self, testsuite, machine_name): + """Get machine detail by name.""" + reject_unknown_params(set()) + ts = g.ts + session = g.db_session + machine = lookup_machine(session, ts, machine_name) + data = _serialize_machine(machine) + return add_etag_to_response(jsonify(data), data) + + @require_scope('manage') + @blp.arguments(MachineUpdateSchema) + @blp.response(200, MachineResponseSchema) + def patch(self, body, testsuite, machine_name): + """Update machine name and/or info. + + On rename, returns a Location header with the new URL. + """ + ts = g.ts + session = g.db_session + machine = lookup_machine(session, ts, machine_name) + + new_name = body.get('name') + renamed = False + + if new_name is not None: + new_name = new_name.strip() + + if new_name != machine.name: + # Check uniqueness of new name + existing = session.query(ts.Machine).filter( + ts.Machine.name == new_name + ).first() + if existing: + abort_with_error( + 409, + "A machine named '%s' already exists" % new_name) + machine.name = new_name + renamed = True + + new_info = body.get('info') + if new_info is not None and isinstance(new_info, dict): + declared = {f.name for f in ts.machine_fields} + params = {} + for key, value in new_info.items(): + if key in declared: + setattr(machine, key, value) + else: + params[key] = value + machine.parameters = params + + session.flush() + + result = _serialize_machine(machine) + resp = jsonify(result) + + if renamed: + new_url = '/api/v5/%s/machines/%s' % ( + testsuite, machine.name) + resp.headers['Location'] = new_url + + return resp + + @require_scope('manage') + @blp.response(204) + def delete(self, testsuite, machine_name): + """Delete machine and all its associated runs and data.""" + ts = g.ts + session = g.db_session + machine = lookup_machine(session, ts, machine_name) + + # Step 1: Clean up FK references to this machine's FieldChanges. + # Both ChangeIgnore and RegressionIndicator have FKs to FieldChange + # but may not cascade properly on all backends (especially Postgres), + # so we must delete these manually before the machine cascade deletes + # FieldChanges. + field_change_ids = session.query(ts.FieldChange.id).filter( + ts.FieldChange.machine_id == machine.id + ).all() + fc_ids = [fc_id for (fc_id,) in field_change_ids] + + if fc_ids: + # Delete in batches to avoid large IN clauses + batch_size = 100 + for i in range(0, len(fc_ids), batch_size): + batch = fc_ids[i:i + batch_size] + session.query(ts.RegressionIndicator).filter( + ts.RegressionIndicator.field_change_id.in_(batch) + ).delete(synchronize_session='fetch') + session.query(ts.ChangeIgnore).filter( + ts.ChangeIgnore.field_change_id.in_(batch) + ).delete(synchronize_session='fetch') + session.flush() + + # Step 2: Delete runs in chunks (each run cascades to its samples, + # field changes, etc.) + batch_size = 50 + while True: + runs = session.query(ts.Run).filter( + ts.Run.machine_id == machine.id + ).limit(batch_size).all() + if not runs: + break + for run in runs: + session.delete(run) + session.flush() + + # Step 3: Delete the machine itself + session.delete(machine) + session.flush() + + return make_response('', 204) + + +@blp.route('/machines//runs') +class MachineRuns(MethodView): + """List runs for a specific machine.""" + + @require_scope('read') + @blp.arguments(MachineRunsQuerySchema, location="query") + @blp.response(200, PaginatedMachineRunResponseSchema) + def get(self, query_args, testsuite, machine_name): + """List runs for a machine (cursor-paginated).""" + reject_unknown_params({'after', 'before', 'sort', 'cursor', 'limit'}) + ts = g.ts + session = g.db_session + machine = lookup_machine(session, ts, machine_name) + + query = session.query(ts.Run).filter( + ts.Run.machine_id == machine.id + ) + + # Apply datetime filters + after_str = query_args.get('after') + if after_str: + after_dt = parse_datetime(after_str) + if after_dt is None: + abort_with_error(400, "Invalid 'after' datetime format") + query = query.filter(ts.Run.start_time > after_dt) + + before_str = query_args.get('before') + if before_str: + before_dt = parse_datetime(before_str) + if before_dt is None: + abort_with_error(400, "Invalid 'before' datetime format") + query = query.filter(ts.Run.start_time < before_dt) + + # Sort: default is ascending by ID (insertion order). + # If sort=-start_time, order descending by ID (most recent first). + sort = query_args.get('sort') + descending = (sort == '-start_time') + + cursor_str = query_args.get('cursor') + limit = query_args['limit'] + items, next_cursor = cursor_paginate( + query, ts.Run.id, cursor_str, limit, descending=descending) + + serialized = [serialize_run(run, ts) for run in items] + return jsonify(make_paginated_response(serialized, next_cursor)) diff --git a/lnt/server/api/v5/endpoints/orders.py b/lnt/server/api/v5/endpoints/orders.py new file mode 100644 index 000000000..42bd09ed2 --- /dev/null +++ b/lnt/server/api/v5/endpoints/orders.py @@ -0,0 +1,249 @@ +"""Order endpoints for the v5 API. + +GET /api/v5/{ts}/orders -- List orders (cursor-paginated) +POST /api/v5/{ts}/orders -- Create order +GET /api/v5/{ts}/orders/{order_value} -- Order detail (includes prev/next) +PATCH /api/v5/{ts}/orders/{order_value} -- Update order metadata +DELETE /api/v5/{ts}/orders/{order_value} -- Not allowed (405) +""" + +from flask import g, jsonify, request +from flask.views import MethodView +from flask_smorest import Blueprint + +from ..auth import require_scope +from ..errors import abort_with_error, reject_unknown_params +from ..etag import add_etag_to_response +from ..helpers import escape_like, validate_tag +from ..pagination import ( + cursor_paginate, + make_paginated_response, +) +from ..schemas.orders import ( + OrderDetailQuerySchema, + OrderDetailSchema, + OrderListQuerySchema, + PaginatedOrderResponseSchema, +) + +blp = Blueprint( + 'Orders', + __name__, + url_prefix='/api/v5/', + description='List, create, and inspect orders (revisions) with previous/next navigation', +) + + +# --------------------------------------------------------------------------- +# Helpers +# --------------------------------------------------------------------------- + +def _serialize_order_fields(order, ts): + """Return a dict of {field_name: value} for the given order.""" + result = {} + for field in ts.order_fields: + val = order.get_field(field) + if val is not None: + result[field.name] = str(val) + return result + + +def _serialize_order_summary(order, ts): + """Serialize an order for list responses.""" + return { + 'fields': _serialize_order_fields(order, ts), + 'tag': order.tag, + } + + +def _order_detail_url(testsuite, order, ts): + """Build the detail URL for an order using its primary field value.""" + primary_field = ts.order_fields[0] + primary_value = order.get_field(primary_field) + return '/api/v5/%s/orders/%s' % (testsuite, primary_value) + + +def _serialize_order_neighbor(order, testsuite, ts): + """Serialize a previous/next order reference, or None.""" + if order is None: + return None + return { + 'fields': _serialize_order_fields(order, ts), + 'link': _order_detail_url(testsuite, order, ts), + } + + +def _serialize_order_detail(order, testsuite, ts): + """Serialize an order for detail responses, including prev/next.""" + return { + 'fields': _serialize_order_fields(order, ts), + 'tag': order.tag, + 'previous_order': _serialize_order_neighbor( + order.previous_order, testsuite, ts), + 'next_order': _serialize_order_neighbor( + order.next_order, testsuite, ts), + } + + +def _lookup_order_by_value(session, ts, order_value): + """Look up an order by its primary field value and optional extra + query parameters for multi-field orders. + + Returns the Order instance. Aborts with 404 or 409 as appropriate. + """ + primary_field = ts.order_fields[0] + query = session.query(ts.Order).filter( + primary_field.column == order_value + ) + + # For multi-field orders, use additional query parameters to + # disambiguate. + if len(ts.order_fields) > 1: + for field in ts.order_fields[1:]: + extra_value = request.args.get(field.name) + if extra_value is not None: + query = query.filter(field.column == extra_value) + + orders = query.all() + + if len(orders) == 0: + abort_with_error(404, "Order '%s' not found" % order_value) + elif len(orders) > 1: + field_names = ', '.join(f.name for f in ts.order_fields[1:]) + abort_with_error( + 409, + "Multiple orders match '%s'. Disambiguate with query " + "parameters: %s" % (order_value, field_names)) + + return orders[0] + + +# --------------------------------------------------------------------------- +# Endpoints +# --------------------------------------------------------------------------- + +@blp.route('/orders') +class OrderList(MethodView): + """List and create orders.""" + + @require_scope('read') + @blp.arguments(OrderListQuerySchema, location="query") + @blp.response(200, PaginatedOrderResponseSchema) + def get(self, query_args, testsuite): + """List orders (cursor-paginated).""" + reject_unknown_params({'cursor', 'limit', 'tag', 'tag_prefix'}) + ts = g.ts + session = g.db_session + + query = session.query(ts.Order) + + # Filter by tag + tag_value = query_args.get('tag') + if tag_value: + query = query.filter(ts.Order.tag == tag_value) + + tag_prefix = query_args.get('tag_prefix') + if tag_prefix: + escaped = escape_like(tag_prefix) + query = query.filter( + ts.Order.tag.like(escaped + '%', escape='\\')) + + cursor_str = query_args.get('cursor') + limit = query_args['limit'] + items, next_cursor = cursor_paginate( + query, ts.Order.id, cursor_str, limit) + + serialized = [_serialize_order_summary(o, ts) for o in items] + return jsonify(make_paginated_response(serialized, next_cursor)) + + @require_scope('submit') + @blp.response(201, OrderDetailSchema) + def post(self, testsuite): + """Create an order explicitly.""" + ts = g.ts + session = g.db_session + + data = request.get_json(silent=True) + if not data: + abort_with_error(400, "Request body must be valid JSON") + + # Validate that all order fields are present. + for field in ts.order_fields: + if field.name not in data: + abort_with_error( + 400, + "Missing required order field: '%s'" % field.name) + + # Check if an order with these exact field values already exists. + query = session.query(ts.Order) + for field in ts.order_fields: + query = query.filter(field.column == data[field.name]) + existing = query.first() + if existing is not None: + abort_with_error( + 409, + "An order with these field values already exists") + + # Create the order. Use _getOrCreateOrder which also maintains + # the linked-list (previous/next) ordering. + # + # _getOrCreateOrder expects a dict and pops order field keys from + # it, so we give it a copy. + params_copy = dict(data) + order = ts._getOrCreateOrder(session, params_copy) + + # Set optional tag. + if 'tag' in data: + order.tag = validate_tag(data['tag']) + + session.flush() + + result = _serialize_order_detail(order, testsuite, ts) + resp = jsonify(result) + resp.status_code = 201 + return resp + + +@blp.route('/orders/') +class OrderDetail(MethodView): + """Order detail, update, and (disallowed) delete.""" + + @require_scope('read') + @blp.arguments(OrderDetailQuerySchema, location="query") + @blp.response(200, OrderDetailSchema) + def get(self, query_args, testsuite, order_value): + """Get order detail by primary field value. + + The response includes previous_order and next_order references. + For multi-field orders, pass additional query parameters to + disambiguate. + """ + ts = g.ts + # Allow dynamic order field names for disambiguation. + valid = {f.name for f in ts.order_fields[1:]} + reject_unknown_params(valid) + session = g.db_session + order = _lookup_order_by_value(session, ts, order_value) + data = _serialize_order_detail(order, testsuite, ts) + return add_etag_to_response(jsonify(data), data) + + @require_scope('manage') + @blp.response(200, OrderDetailSchema) + def patch(self, testsuite, order_value): + """Update order metadata.""" + ts = g.ts + session = g.db_session + order = _lookup_order_by_value(session, ts, order_value) + + data = request.get_json(silent=True) + if not data: + abort_with_error(400, "Request body must be valid JSON") + + # Update tag if provided. Check key presence to distinguish + # "not provided" from an explicit null (which clears the tag). + if 'tag' in data: + order.tag = validate_tag(data['tag']) + + session.flush() + + return jsonify(_serialize_order_detail(order, testsuite, ts)) diff --git a/lnt/server/api/v5/endpoints/profiles.py b/lnt/server/api/v5/endpoints/profiles.py new file mode 100644 index 000000000..d58b06592 --- /dev/null +++ b/lnt/server/api/v5/endpoints/profiles.py @@ -0,0 +1,182 @@ +"""Profile endpoints for the v5 API. + +GET /api/v5/{ts}/runs/{uuid}/tests/{test_name}/profile + -- Profile metadata + top-level counters +GET /api/v5/{ts}/runs/{uuid}/tests/{test_name}/profile/functions + -- List functions with counters +GET /api/v5/{ts}/runs/{uuid}/tests/{test_name}/profile/functions/{fn_name} + -- Disassembly + per-instruction counters +""" + +from flask import current_app, g, jsonify +from flask.views import MethodView +from flask_smorest import Blueprint + +from ..auth import require_scope +from ..errors import abort_with_error, reject_unknown_params +from ..helpers import lookup_run_by_uuid, lookup_test +from ..schemas.profiles import ( + FunctionDetailSchema, + FunctionListResponseSchema, + ProfileMetadataSchema, +) + +blp = Blueprint( + 'Profiles', + __name__, + url_prefix='/api/v5/', + description='Inspect hardware performance counter profiles attached to samples', +) + + +def _get_sample_with_profile(session, ts, run, test): + """Find the sample for run+test that has a profile attached. + + Aborts with 404 if no sample with profile is found. + """ + sample = session.query(ts.Sample).filter( + ts.Sample.run_id == run.id, + ts.Sample.test_id == test.id, + ts.Sample.profile_id.isnot(None), + ).first() + if sample is None: + abort_with_error( + 404, + "No profile found for test '%s' in run '%s'" % + (test.name, run.uuid)) + return sample + + +def _load_profile(sample): + """Load the profile from disk for the given sample. + + Uses current_app.old_config.profileDir to locate profile files. + Aborts with 404 if the profile file is missing or cannot be loaded. + """ + profile_dir = current_app.old_config.profileDir + try: + p = sample.profile.load(profile_dir) + except Exception: + abort_with_error( + 404, + "Profile file for this sample is missing or cannot be loaded. " + "The profile data file may have been deleted from disk.") + if p is None: + abort_with_error( + 404, + "Profile file for this sample is missing or cannot be loaded.") + return p + + +@blp.route('/runs//tests//profile') +class ProfileMetadata(MethodView): + """Profile metadata and top-level counters.""" + + @require_scope('read') + @blp.response(200, ProfileMetadataSchema) + def get(self, testsuite, run_uuid, test_name): + """Get profile metadata and top-level counters. + + Returns the test name and absolute counter values for the + entire profile. + """ + reject_unknown_params(set()) + ts = g.ts + session = g.db_session + run = lookup_run_by_uuid(session, ts, run_uuid) + test = lookup_test(session, ts, test_name) + sample = _get_sample_with_profile(session, ts, run, test) + p = _load_profile(sample) + + counters = p.getTopLevelCounters() + return jsonify({ + 'test': test.name, + 'counters': counters, + }) + + +@blp.route( + '/runs//tests//profile/functions') +class ProfileFunctions(MethodView): + """List functions in a profile with their counters.""" + + @require_scope('read') + @blp.response(200, FunctionListResponseSchema) + def get(self, testsuite, run_uuid, test_name): + """List functions with counters. + + Returns all functions in the profile with their counter values + (as percentages) and instruction count. The function list is + NOT paginated (typically small). + """ + reject_unknown_params(set()) + ts = g.ts + session = g.db_session + run = lookup_run_by_uuid(session, ts, run_uuid) + test = lookup_test(session, ts, test_name) + sample = _get_sample_with_profile(session, ts, run, test) + p = _load_profile(sample) + + functions_dict = p.getFunctions() + functions = [] + for fn_name, fn_info in functions_dict.items(): + functions.append({ + 'name': fn_name, + 'counters': fn_info.get('counters', {}), + 'length': fn_info.get('length', 0), + }) + + return jsonify({'functions': functions}) + + +@blp.route( + '/runs//tests/' + '/profile/functions/') +class ProfileFunctionDetail(MethodView): + """Disassembly and per-instruction counters for a function.""" + + @require_scope('read') + @blp.response(200, FunctionDetailSchema) + def get(self, testsuite, run_uuid, test_name, fn_name): + """Get disassembly and per-instruction counters for a function. + + Returns the function's counters, disassembly format, and a list + of instructions with their addresses, counter values, and + disassembly text. + """ + reject_unknown_params(set()) + ts = g.ts + session = g.db_session + run = lookup_run_by_uuid(session, ts, run_uuid) + test = lookup_test(session, ts, test_name) + sample = _get_sample_with_profile(session, ts, run, test) + p = _load_profile(sample) + + functions_dict = p.getFunctions() + if fn_name not in functions_dict: + abort_with_error( + 404, + "Function '%s' not found in profile" % fn_name) + + fn_info = functions_dict[fn_name] + disassembly_format = p.getDisassemblyFormat() + + instructions = [] + try: + for address, counters, text in p.getCodeForFunction(fn_name): + instructions.append({ + 'address': address, + 'counters': counters, + 'text': text, + }) + except KeyError: + abort_with_error( + 404, + "Function '%s' not found in profile" % fn_name) + + return jsonify({ + 'name': fn_name, + 'counters': fn_info.get('counters', {}), + 'disassembly_format': disassembly_format, + 'instructions': instructions, + }) diff --git a/lnt/server/api/v5/endpoints/query.py b/lnt/server/api/v5/endpoints/query.py new file mode 100644 index 000000000..24670159d --- /dev/null +++ b/lnt/server/api/v5/endpoints/query.py @@ -0,0 +1,467 @@ +"""Query endpoint for the v5 API. + +GET /api/v5/{ts}/query?metric={name}&machine={name}&test={name} + &after_order={order}&before_order={order} + &after_time={iso8601}&before_time={iso8601} + &sort={fields}&limit={n}&cursor={c} + +Returns cursor-paginated data points. The metric parameter is required; +all other filter parameters are optional. +""" + +import base64 + +from flask import g, jsonify +from flask.views import MethodView +from flask_smorest import Blueprint +from sqlalchemy import and_, or_ + +from lnt.testing import PASS + +from ..auth import require_scope +from ..errors import abort_with_error, reject_unknown_params +from ..helpers import parse_datetime, resolve_metric +from ..pagination import make_paginated_response +from ..schemas.query import QueryEndpointQuerySchema, QueryResponseSchema + +blp = Blueprint( + 'Query', + __name__, + url_prefix='/api/v5/', + description='Query time-series performance data across machines, tests, and metrics', +) + +# Default and maximum page sizes. +_DEFAULT_LIMIT = 100 +_MAX_LIMIT = 10000 + +# Valid query parameter names for the /query endpoint. +_VALID_QUERY_PARAMS = { + 'machine', 'test', 'metric', + 'after_order', 'before_order', 'after_time', 'before_time', + 'sort', 'limit', 'cursor', +} + +# Allowed sort field names and the columns they map to. +# The actual column references are resolved at query time since the +# model classes are dynamic per test suite. +_ALLOWED_SORT_FIELDS = {'test', 'order', 'timestamp'} + + +def _parse_sort(sort_str): + """Parse a comma-separated sort string into (field_name, ascending) pairs. + + Examples: + "test,order" -> [("test", True), ("order", True)] + "-timestamp,test" -> [("timestamp", False), ("test", True)] + + Returns a list of (field_name, ascending) tuples, or None on error. + """ + if not sort_str: + return [('order', True), ('test', True)] + + result = [] + seen = set() + for part in sort_str.split(','): + part = part.strip() + if not part: + continue + if part.startswith('-'): + ascending = False + field_name = part[1:] + else: + ascending = True + field_name = part + if field_name not in _ALLOWED_SORT_FIELDS: + return None + if field_name in seen: + continue + seen.add(field_name) + result.append((field_name, ascending)) + + if not result: + return None + + # Append tiebreakers for deterministic ordering. + for tiebreaker in ('order', 'test'): + if tiebreaker not in seen: + result.append((tiebreaker, True)) + seen.add(tiebreaker) + + return result + + +def _resolve_sort_column(ts, field_name): + """Map a sort field name to its SQLAlchemy column.""" + if field_name == 'test': + return ts.Test.name + elif field_name == 'order': + return ts.Order.id + elif field_name == 'timestamp': + return ts.Run.start_time + raise ValueError("Unknown sort field: %s" % field_name) + + +def _encode_cursor(values): + """Encode a list of cursor values into an opaque string. + + Values are JSON-encoded then base64-wrapped to safely handle + values containing any characters (colons, unicode, etc.). + """ + import json + payload = json.dumps(values, separators=(',', ':')) + return base64.urlsafe_b64encode(payload.encode('utf-8')).decode('ascii') + + +def _decode_cursor(cursor_str, num_fields): + """Decode a cursor string back into a list of values. + + Returns None if the cursor is malformed. + """ + import json + if not cursor_str: + return None + try: + decoded = base64.urlsafe_b64decode( + cursor_str.encode('ascii')).decode('utf-8') + parts = json.loads(decoded) + if not isinstance(parts, list) or len(parts) != num_fields: + return None + return parts + except (ValueError, TypeError, UnicodeDecodeError, json.JSONDecodeError): + return None + + +def _build_cursor_filter(ts, sort_spec, cursor_values): + """Build a SQLAlchemy filter expression for cursor-based pagination. + + For mixed ASC/DESC sort orders, expands to an OR chain: + (col1 > v1) + OR (col1 = v1 AND col2 < v2) -- if col2 is DESC + OR (col1 = v1 AND col2 = v2 AND col3 > v3) + ... + """ + conditions = [] + for i in range(len(sort_spec)): + field_name, ascending = sort_spec[i] + col = _resolve_sort_column(ts, field_name) + cursor_val = _coerce_cursor_value(field_name, cursor_values[i]) + + # All prefix columns must be equal + prefix_conditions = [] + for j in range(i): + pf_name, _ = sort_spec[j] + pf_col = _resolve_sort_column(ts, pf_name) + pf_val = _coerce_cursor_value(pf_name, cursor_values[j]) + prefix_conditions.append(pf_col == pf_val) + + # The i-th column uses > (ASC) or < (DESC) + if ascending: + cmp = col > cursor_val + else: + cmp = col < cursor_val + + if prefix_conditions: + conditions.append(and_(*prefix_conditions, cmp)) + else: + conditions.append(cmp) + + return or_(*conditions) + + +def _coerce_cursor_value(field_name, value): + """Coerce a cursor value to the appropriate Python type. + + With JSON-encoded cursors, values are already the right type + in most cases. This handles edge cases and type enforcement. + Raises ValueError if the value cannot be coerced. + """ + if field_name == 'order': + return int(value) + elif field_name == 'test': + return str(value) if value is not None else '' + elif field_name == 'timestamp': + return value # None or string, both valid + return value + + +def _extract_cursor_values(sort_spec, ts, row_data): + """Extract cursor values from a result row for encoding. + + row_data is a dict with keys: test_name, order_id, timestamp. + """ + values = [] + for field_name, _ in sort_spec: + if field_name == 'test': + values.append(row_data['test_name']) + elif field_name == 'order': + values.append(row_data['order_id']) + elif field_name == 'timestamp': + values.append(row_data['timestamp']) + return values + + +def _resolve_machine(session, ts, machine_name): + """Resolve a machine name to its model instance. + + Returns (machine, None, None) on success, or + (None, error_message, http_status) on failure. + """ + machines = session.query(ts.Machine).filter( + ts.Machine.name == machine_name + ).all() + if len(machines) == 0: + return None, "Machine '%s' not found" % machine_name, 404 + if len(machines) > 1: + ids = ', '.join(str(m.id) for m in machines) + return None, ( + "Multiple machines named '%s' exist (IDs: %s). " + "Use the v4 UI to merge or rename them." + % (machine_name, ids)), 409 + return machines[0], None, None + + +def _resolve_test(session, ts, test_name): + """Resolve a test name to its model instance.""" + test = session.query(ts.Test).filter( + ts.Test.name == test_name + ).first() + if test is None: + return None, "Test '%s' not found" % test_name + return test, None + + +def _resolve_order(session, ts, order_value): + """Resolve an order field value to its model instance. + + Matches against the first (primary) order field. + """ + if not ts.order_fields: + return None, "Test suite has no order fields" + primary_field = ts.order_fields[0] + order = session.query(ts.Order).filter( + primary_field.column == order_value + ).first() + if order is None: + return None, "Order '%s' not found" % order_value + return order, None + + +def _query_for_field(session, ts, sample_field, machine, test, + sort_spec, cursor_values, after_order, before_order, + after_time, before_time, limit): + """Build and execute a query for a single sample field. + + Returns a list of dicts ready for serialization, plus a boolean + indicating whether there are more results. + """ + q = session.query( + sample_field.column, + ts.Order, + ts.Run, + ts.Test, + ts.Machine, + ).select_from(ts.Sample) \ + .join(ts.Run) \ + .join(ts.Order) \ + .join(ts.Test) \ + .join(ts.Machine, ts.Run.machine_id == ts.Machine.id) \ + .filter(sample_field.column.isnot(None)) + + # Filter out failing tests if the field has a status_field. + if sample_field.status_field: + q = q.filter( + (sample_field.status_field.column == PASS) | + (sample_field.status_field.column.is_(None)) + ) + + # Apply optional filters. + if machine is not None: + q = q.filter(ts.Run.machine_id == machine.id) + if test is not None: + q = q.filter(ts.Sample.test_id == test.id) + + # Apply order range filters. + if after_order is not None: + q = q.filter(ts.Order.id > after_order.id) + if before_order is not None: + q = q.filter(ts.Order.id < before_order.id) + + # Apply timestamp range filters. + if after_time is not None: + q = q.filter(ts.Run.start_time > after_time) + if before_time is not None: + q = q.filter(ts.Run.start_time < before_time) + + # Apply cursor filter. + if cursor_values is not None: + try: + q = q.filter(_build_cursor_filter(ts, sort_spec, cursor_values)) + except (ValueError, TypeError): + abort_with_error(400, "Invalid pagination cursor") + + # Apply ordering. + for field_name, ascending in sort_spec: + col = _resolve_sort_column(ts, field_name) + q = q.order_by(col.asc() if ascending else col.desc()) + + # Fetch limit + 1 to detect next page. + rows = q.limit(limit + 1).all() + + has_next = len(rows) > limit + rows = rows[:limit] + + items = [] + for value, order, run, test_obj, machine_obj in rows: + order_dict = {} + for of in order.fields: + val = order.get_field(of) + if val is not None: + order_dict[of.name] = str(val) + + timestamp = None + if run.start_time: + timestamp = run.start_time.isoformat() + + items.append({ + 'test': test_obj.name, + 'machine': machine_obj.name, + 'metric': sample_field.name, + 'value': value, + 'order': order_dict, + 'run_uuid': run.uuid, + 'timestamp': timestamp, + '_order_id': order.id, + }) + + return items, has_next + + +@blp.route('/query') +class QueryView(MethodView): + """Query data points.""" + + @require_scope('read') + @blp.arguments(QueryEndpointQuerySchema, location="query") + @blp.response(200, QueryResponseSchema) + def get(self, query_args, testsuite): + """Query data points. + + Returns cursor-paginated data points. The metric parameter is + required; all other filter parameters are optional -- omit any + to get data across all values of that dimension. + """ + # Reject unknown query parameters early so that typos like + # ``machine_name=`` or ``metric_name=`` don't silently return + # unfiltered data. + reject_unknown_params(_VALID_QUERY_PARAMS) + + ts = g.ts + session = g.db_session + + # ------------------------------------------------------------------ + # Parse filter parameters + # ------------------------------------------------------------------ + machine_name = query_args.get('machine') + test_name = query_args.get('test') + field_name = query_args['metric'] + + # Resolve entities when provided. + machine = None + if machine_name: + machine, err, status = _resolve_machine(session, ts, machine_name) + if err: + abort_with_error(status, err) + + test = None + if test_name: + test, err = _resolve_test(session, ts, test_name) + if err: + abort_with_error(404, err) + + field = resolve_metric(ts, field_name) + + # ------------------------------------------------------------------ + # Parse sort parameter + # ------------------------------------------------------------------ + sort_str = query_args.get('sort') + sort_spec = _parse_sort(sort_str) + if sort_spec is None: + abort_with_error( + 400, "Invalid sort parameter. Allowed fields: %s. " + "Use - prefix for descending." + % ', '.join(sorted(_ALLOWED_SORT_FIELDS))) + + # ------------------------------------------------------------------ + # Parse range filters + # ------------------------------------------------------------------ + after_order_str = query_args.get('after_order') + before_order_str = query_args.get('before_order') + after_time_str = query_args.get('after_time') + before_time_str = query_args.get('before_time') + + after_order = None + if after_order_str: + after_order, err = _resolve_order(session, ts, after_order_str) + if err: + abort_with_error(404, err) + + before_order = None + if before_order_str: + before_order, err = _resolve_order(session, ts, before_order_str) + if err: + abort_with_error(404, err) + + after_time = None + if after_time_str: + after_time = parse_datetime(after_time_str) + if after_time is None: + abort_with_error( + 400, "Invalid after_time format, expected ISO 8601") + + before_time = None + if before_time_str: + before_time = parse_datetime(before_time_str) + if before_time is None: + abort_with_error( + 400, "Invalid before_time format, expected ISO 8601") + + # ------------------------------------------------------------------ + # Parse pagination parameters + # ------------------------------------------------------------------ + limit = query_args['limit'] + limit = max(1, min(limit, _MAX_LIMIT)) + + cursor_str = query_args.get('cursor') + cursor_values = None + if cursor_str: + cursor_values = _decode_cursor(cursor_str, len(sort_spec)) + if cursor_values is None: + abort_with_error(400, "Invalid pagination cursor") + + # ------------------------------------------------------------------ + # Execute query + # ------------------------------------------------------------------ + items, has_next = _query_for_field( + session, ts, field, machine, test, + sort_spec, cursor_values, after_order, before_order, + after_time, before_time, limit) + + # ------------------------------------------------------------------ + # Build cursor and response + # ------------------------------------------------------------------ + next_cursor = None + if has_next and items: + last = items[-1] + cursor_vals = _extract_cursor_values(sort_spec, ts, { + 'test_name': last['test'], + 'order_id': last['_order_id'], + 'timestamp': last['timestamp'], + }) + next_cursor = _encode_cursor(cursor_vals) + + # Strip internal fields before returning. + for item in items: + item.pop('_order_id', None) + + return jsonify(make_paginated_response(items, next_cursor)) diff --git a/lnt/server/api/v5/endpoints/regressions.py b/lnt/server/api/v5/endpoints/regressions.py new file mode 100644 index 000000000..ca28931f9 --- /dev/null +++ b/lnt/server/api/v5/endpoints/regressions.py @@ -0,0 +1,554 @@ +"""Regression endpoints for the v5 API. + +GET /api/v5/{ts}/regressions -- List +POST /api/v5/{ts}/regressions -- Create +GET /api/v5/{ts}/regressions/{uuid} -- Detail +PATCH /api/v5/{ts}/regressions/{uuid} -- Update +DELETE /api/v5/{ts}/regressions/{uuid} -- Delete +POST /api/v5/{ts}/regressions/{uuid}/merge -- Merge +POST /api/v5/{ts}/regressions/{uuid}/split -- Split +GET /api/v5/{ts}/regressions/{uuid}/indicators -- List indicators +POST /api/v5/{ts}/regressions/{uuid}/indicators -- Add indicator +DELETE /api/v5/{ts}/regressions/{uuid}/indicators/{fc_uuid} -- Remove indicator +""" + +import uuid as uuid_module + +from flask import g, jsonify, make_response +from flask.views import MethodView +from flask_smorest import Blueprint + +from ..auth import require_scope +from ..errors import abort_with_error, reject_unknown_params +from ..helpers import ( + lookup_fieldchange, + lookup_regression, + resolve_metric, + serialize_fieldchange, +) +from ..etag import add_etag_to_response +from ..pagination import ( + cursor_paginate, + make_paginated_response, +) +from ..schemas.regressions import ( + IndicatorAddSchema, + IndicatorResponseSchema, + PaginatedIndicatorResponseSchema, + PaginatedRegressionListSchema, + RegressionCreateSchema, + RegressionDetailSchema, + RegressionIndicatorsQuerySchema, + RegressionListQuerySchema, + RegressionMergeSchema, + RegressionSplitSchema, + RegressionUpdateSchema, + STATE_TO_DB, + state_to_api, + state_to_db, +) + +blp = Blueprint( + 'Regressions', + __name__, + url_prefix='/api/v5/', + description='Triage performance regressions: create, merge, split, and manage indicators', +) + + +# --------------------------------------------------------------------------- +# Helpers +# --------------------------------------------------------------------------- + +def _serialize_indicator(ri, ts): + """Serialize a RegressionIndicator into the API response dict.""" + fc = ri.field_change + if fc is None: + return None + + result = serialize_fieldchange(fc) + result['field_change_uuid'] = fc.uuid + return result + + +def _serialize_regression_list(regression): + """Serialize a Regression for the list endpoint (no indicators).""" + return { + 'uuid': regression.uuid, + 'title': regression.title, + 'bug': regression.bug, + 'state': state_to_api(regression.state), + } + + +def _serialize_regression_detail(regression, session, ts): + """Serialize a Regression for the detail endpoint (with indicators).""" + indicators = session.query(ts.RegressionIndicator).filter( + ts.RegressionIndicator.regression_id == regression.id + ).all() + + serialized_indicators = [] + for ri in indicators: + ind = _serialize_indicator(ri, ts) + if ind is not None: + serialized_indicators.append(ind) + + return { + 'uuid': regression.uuid, + 'title': regression.title, + 'bug': regression.bug, + 'state': state_to_api(regression.state), + 'indicators': serialized_indicators, + } + + +# --------------------------------------------------------------------------- +# Regression List / Create +# --------------------------------------------------------------------------- + +@blp.route('/regressions') +class RegressionList(MethodView): + """List and create regressions.""" + + @require_scope('read') + @blp.arguments(RegressionListQuerySchema, location="query") + @blp.response(200, PaginatedRegressionListSchema) + def get(self, query_args, testsuite): + """List regressions (cursor-paginated, filterable).""" + reject_unknown_params( + {'state', 'machine', 'test', 'metric', 'cursor', 'limit'}) + ts = g.ts + session = g.db_session + + query = session.query(ts.Regression) + + # Filter by state (supports comma-separated values) + state_values = query_args['state'] + if state_values: + db_states = [] + for sv in state_values: + db_val = state_to_db(sv) + if db_val is None: + abort_with_error( + 400, + "Invalid state '%s'. Valid states: %s" + % (sv, ', '.join(sorted(STATE_TO_DB.keys())))) + db_states.append(db_val) + query = query.filter(ts.Regression.state.in_(db_states)) + + # Filter by machine, test, and/or metric name. All three need + # the same base JOINs through indicators -> field changes. + machine_name = query_args.get('machine') + test_name = query_args.get('test') + field_name = query_args.get('metric') + + # Resolve metric name to field ID (no DB query needed) + matching_field = None + if field_name: + matching_field = resolve_metric(ts, field_name) + + if machine_name or test_name or field_name: + query = query.join( + ts.RegressionIndicator, + ts.RegressionIndicator.regression_id == ts.Regression.id + ).join( + ts.FieldChange, + ts.RegressionIndicator.field_change_id == ts.FieldChange.id + ) + + if machine_name: + query = query.join( + ts.Machine, + ts.FieldChange.machine_id == ts.Machine.id + ).filter(ts.Machine.name == machine_name) + + if test_name: + query = query.join( + ts.Test, + ts.FieldChange.test_id == ts.Test.id + ).filter(ts.Test.name == test_name) + + if field_name: + query = query.filter( + ts.FieldChange.field_id == matching_field.id) + + if machine_name or test_name or field_name: + query = query.distinct() + + cursor_str = query_args.get('cursor') + limit = query_args['limit'] + items, next_cursor = cursor_paginate( + query, ts.Regression.id, cursor_str, limit) + + serialized = [_serialize_regression_list(r) for r in items] + return jsonify(make_paginated_response(serialized, next_cursor)) + + @require_scope('triage') + @blp.arguments(RegressionCreateSchema) + @blp.response(201, RegressionDetailSchema) + def post(self, body, testsuite): + """Create a new regression from field changes.""" + ts = g.ts + session = g.db_session + + fc_uuids = body['field_change_uuids'] + + # Look up all field changes by UUID + field_changes = [] + for fc_uuid in fc_uuids: + fc = lookup_fieldchange(session, ts, fc_uuid) + field_changes.append(fc) + + # Determine state + state_str = body.get('state') or 'detected' + db_state = state_to_db(state_str) + if db_state is None: + abort_with_error( + 400, + "Invalid state '%s'. Valid states: %s" + % (state_str, ', '.join(sorted(STATE_TO_DB.keys())))) + + # Create regression + title = body.get('title') or 'Regression of %d benchmarks' % len( + field_changes) + bug = body.get('bug') or '' + + regression = ts.Regression(title, bug, db_state) + regression.uuid = str(uuid_module.uuid4()) + session.add(regression) + session.flush() + + # Add indicators + for fc in field_changes: + ri = ts.RegressionIndicator(regression, fc) + session.add(ri) + session.flush() + + result = _serialize_regression_detail(regression, session, ts) + resp = jsonify(result) + resp.status_code = 201 + return resp + + +# --------------------------------------------------------------------------- +# Regression Detail / Update / Delete +# --------------------------------------------------------------------------- + +@blp.route('/regressions/') +class RegressionDetail(MethodView): + """Regression detail, update, and delete.""" + + @require_scope('read') + @blp.response(200, RegressionDetailSchema) + def get(self, testsuite, regression_uuid): + """Get regression detail with embedded indicators.""" + reject_unknown_params(set()) + ts = g.ts + session = g.db_session + regression = lookup_regression(session, ts, regression_uuid) + data = _serialize_regression_detail(regression, session, ts) + return add_etag_to_response(jsonify(data), data) + + @require_scope('triage') + @blp.arguments(RegressionUpdateSchema) + @blp.response(200, RegressionDetailSchema) + def patch(self, body, testsuite, regression_uuid): + """Update regression title, bug URL, and/or state. + + Request body (all fields optional): + { + "title": "new title", + "bug": "new bug URL", + "state": "active" + } + """ + ts = g.ts + session = g.db_session + regression = lookup_regression(session, ts, regression_uuid) + + if 'title' in body: + regression.title = body['title'] + + if 'bug' in body: + regression.bug = body['bug'] + + if 'state' in body: + db_state = state_to_db(body['state']) + if db_state is None: + abort_with_error( + 400, + "Invalid state '%s'. Valid states: %s" + % (body['state'], + ', '.join(sorted(STATE_TO_DB.keys())))) + regression.state = db_state + + session.flush() + + return jsonify( + _serialize_regression_detail(regression, session, ts)) + + @require_scope('triage') + @blp.response(204) + def delete(self, testsuite, regression_uuid): + """Delete a regression and its indicators.""" + ts = g.ts + session = g.db_session + regression = lookup_regression(session, ts, regression_uuid) + + # Delete indicators first + session.query(ts.RegressionIndicator).filter( + ts.RegressionIndicator.regression_id == regression.id + ).delete(synchronize_session='fetch') + + session.delete(regression) + session.flush() + + return make_response('', 204) + + +# --------------------------------------------------------------------------- +# Merge +# --------------------------------------------------------------------------- + +@blp.route('/regressions//merge') +class RegressionMerge(MethodView): + """Merge source regressions into the target regression.""" + + @require_scope('triage') + @blp.arguments(RegressionMergeSchema) + @blp.response(200, RegressionDetailSchema) + def post(self, body, testsuite, regression_uuid): + """Merge source regressions into this one. + + The target absorbs all indicators from the source regressions. + Sources are marked as ignored. Duplicate indicators are + deduplicated. + """ + ts = g.ts + session = g.db_session + target = lookup_regression(session, ts, regression_uuid) + + source_uuids = body['source_regression_uuids'] + + # Validate: cannot merge into self + for suuid in source_uuids: + if suuid == regression_uuid: + abort_with_error( + 400, "Cannot merge a regression into itself") + + # Collect existing indicator field_change_ids for the target + # (for deduplication) + existing_fc_ids = set() + target_indicators = session.query(ts.RegressionIndicator).filter( + ts.RegressionIndicator.regression_id == target.id + ).all() + for ri in target_indicators: + existing_fc_ids.add(ri.field_change_id) + + # Process each source regression + sources = [] + for suuid in source_uuids: + source = lookup_regression(session, ts, suuid) + sources.append(source) + + for source in sources: + # Move indicators from source to target (with dedup) + source_indicators = session.query(ts.RegressionIndicator).filter( + ts.RegressionIndicator.regression_id == source.id + ).all() + + for ri in source_indicators: + if ri.field_change_id not in existing_fc_ids: + ri.regression_id = target.id + ri.regression = target + existing_fc_ids.add(ri.field_change_id) + else: + # Duplicate -- remove it + session.delete(ri) + + # Mark source as IGNORED + source.state = STATE_TO_DB['ignored'] + + session.flush() + + return jsonify( + _serialize_regression_detail(target, session, ts)) + + +# --------------------------------------------------------------------------- +# Split +# --------------------------------------------------------------------------- + +@blp.route('/regressions//split') +class RegressionSplit(MethodView): + """Split field changes from a regression into a new regression.""" + + @require_scope('triage') + @blp.arguments(RegressionSplitSchema) + @blp.response(201, RegressionDetailSchema) + def post(self, body, testsuite, regression_uuid): + """Split specified field changes into a new regression. + + At least one indicator must remain in the source regression. + """ + ts = g.ts + session = g.db_session + source = lookup_regression(session, ts, regression_uuid) + + fc_uuids = body['field_change_uuids'] + + # Get all current indicators for the source regression + all_indicators = session.query(ts.RegressionIndicator).filter( + ts.RegressionIndicator.regression_id == source.id + ).all() + + # Build a map from field_change_id to indicator + fc_id_to_ri = {} + for ri in all_indicators: + fc_id_to_ri[ri.field_change_id] = ri + + # Resolve the field change UUIDs to indicators + indicators_to_move = [] + for fc_uuid in fc_uuids: + fc = lookup_fieldchange(session, ts, fc_uuid) + ri = fc_id_to_ri.get(fc.id) + if ri is None: + abort_with_error( + 400, + "Field change '%s' is not an indicator of regression " + "'%s'" % (fc_uuid, regression_uuid)) + indicators_to_move.append(ri) + + # Validate: cannot split ALL indicators + if len(indicators_to_move) >= len(all_indicators): + abort_with_error( + 400, + "Cannot split all indicators from a regression. " + "At least one indicator must remain.") + + # Create new regression + new_regression = ts.Regression( + source.title, source.bug or '', source.state) + new_regression.uuid = str(uuid_module.uuid4()) + session.add(new_regression) + session.flush() + + # Move indicators to the new regression + for ri in indicators_to_move: + ri.regression_id = new_regression.id + ri.regression = new_regression + + session.flush() + + return jsonify( + _serialize_regression_detail(new_regression, session, ts)), 201 + + +# --------------------------------------------------------------------------- +# Indicators +# --------------------------------------------------------------------------- + +@blp.route('/regressions//indicators') +class RegressionIndicators(MethodView): + """List and add indicators for a regression.""" + + @require_scope('read') + @blp.arguments(RegressionIndicatorsQuerySchema, location="query") + @blp.response(200, PaginatedIndicatorResponseSchema) + def get(self, query_args, testsuite, regression_uuid): + """List indicators for a regression (cursor-paginated).""" + reject_unknown_params({'cursor', 'limit'}) + ts = g.ts + session = g.db_session + regression = lookup_regression(session, ts, regression_uuid) + + query = session.query(ts.RegressionIndicator).filter( + ts.RegressionIndicator.regression_id == regression.id + ) + + cursor_str = query_args.get('cursor') + limit = query_args['limit'] + items, next_cursor = cursor_paginate( + query, ts.RegressionIndicator.id, cursor_str, limit) + + serialized = [] + for ri in items: + ind = _serialize_indicator(ri, ts) + if ind is not None: + serialized.append(ind) + + return jsonify(make_paginated_response(serialized, next_cursor)) + + @require_scope('triage') + @blp.arguments(IndicatorAddSchema) + @blp.response(201, IndicatorResponseSchema) + def post(self, body, testsuite, regression_uuid): + """Add a field change as an indicator to this regression. + + Request body: + {"field_change_uuid": "..."} + """ + ts = g.ts + session = g.db_session + regression = lookup_regression(session, ts, regression_uuid) + + fc_uuid = body['field_change_uuid'] + fc = lookup_fieldchange(session, ts, fc_uuid) + + # Check for duplicate + existing = session.query(ts.RegressionIndicator).filter( + ts.RegressionIndicator.regression_id == regression.id, + ts.RegressionIndicator.field_change_id == fc.id, + ).first() + if existing: + abort_with_error( + 409, + "Field change '%s' is already an indicator of this " + "regression" % fc_uuid) + + ri = ts.RegressionIndicator(regression, fc) + session.add(ri) + session.flush() + + result = _serialize_indicator(ri, ts) + resp = jsonify(result) + resp.status_code = 201 + return resp + + +@blp.route( + '/regressions//indicators/') +class RegressionIndicatorRemove(MethodView): + """Remove a field change indicator from a regression.""" + + @require_scope('triage') + @blp.response(204) + def delete(self, testsuite, regression_uuid, fc_uuid): + """Remove a field change indicator from a regression.""" + ts = g.ts + session = g.db_session + regression = lookup_regression(session, ts, regression_uuid) + + # Find the field change by UUID + fc = session.query(ts.FieldChange).filter( + ts.FieldChange.uuid == fc_uuid + ).first() + if fc is None: + abort_with_error( + 404, "Field change '%s' not found" % fc_uuid) + + # Find the indicator linking this field change to this regression + ri = session.query(ts.RegressionIndicator).filter( + ts.RegressionIndicator.regression_id == regression.id, + ts.RegressionIndicator.field_change_id == fc.id, + ).first() + if ri is None: + abort_with_error( + 404, + "Field change '%s' is not an indicator of regression " + "'%s'" % (fc_uuid, regression_uuid)) + + session.delete(ri) + session.flush() + + return make_response('', 204) diff --git a/lnt/server/api/v5/endpoints/runs.py b/lnt/server/api/v5/endpoints/runs.py new file mode 100644 index 000000000..804d97641 --- /dev/null +++ b/lnt/server/api/v5/endpoints/runs.py @@ -0,0 +1,237 @@ +"""Run endpoints for the v5 API. + +GET /api/v5/{ts}/runs -- List runs (cursor-paginated) +POST /api/v5/{ts}/runs -- Submit run (reuses import pipeline) +GET /api/v5/{ts}/runs/{uuid} -- Run detail +DELETE /api/v5/{ts}/runs/{uuid} -- Delete run +""" + +import json + +import lnt.util.ImportData +from flask import current_app, g, jsonify, make_response, request +from flask.views import MethodView +from flask_smorest import Blueprint +from sqlalchemy.orm import joinedload + +from ..auth import require_scope +from ..errors import abort_with_error, reject_unknown_params +from ..etag import add_etag_to_response +from ..helpers import parse_datetime, serialize_run +from ..pagination import ( + cursor_paginate, + make_paginated_response, +) +from ..schemas.runs import ( + PaginatedRunResponseSchema, + RunListQuerySchema, + RunResponseSchema, + RunSubmitQuerySchema, + RunSubmitResponseSchema, +) + +# Maps v5 on_machine_conflict values to internal select_machine values. +_CONFLICT_MAP = {'reject': 'match', 'update': 'update'} + +# Maps v5 on_existing_run values to internal merge_run values. +_MERGE_MAP = {'reject': 'reject', 'replace': 'replace', 'create': 'append'} + +blp = Blueprint( + 'Runs', + __name__, + url_prefix='/api/v5/', + description='Submit, list, inspect, and delete test runs', +) + + +@blp.route('/runs') +class RunList(MethodView): + """List runs and submit new runs.""" + + @require_scope('read') + @blp.arguments(RunListQuerySchema, location="query") + @blp.response(200, PaginatedRunResponseSchema) + def get(self, query_args, testsuite): + """List runs (cursor-paginated, filterable).""" + reject_unknown_params( + {'machine', 'order', 'after', 'before', 'sort', 'cursor', 'limit'}) + ts = g.ts + session = g.db_session + + query = session.query(ts.Run).options( + joinedload(ts.Run.machine), + joinedload(ts.Run.order), + ) + + # Filter by machine name + machine_name = query_args.get('machine') + if machine_name: + machine = session.query(ts.Machine).filter( + ts.Machine.name == machine_name + ).first() + if machine is None: + return jsonify(make_paginated_response([], None)) + query = query.filter(ts.Run.machine_id == machine.id) + + # Filter by order (primary order field value) + order_value = query_args.get('order') + if order_value: + # Look up orders matching the primary field value + primary_field = ts.order_fields[0] + matching_orders = session.query(ts.Order).filter( + primary_field.column == order_value + ).all() + if not matching_orders: + return jsonify(make_paginated_response([], None)) + order_ids = [o.id for o in matching_orders] + query = query.filter(ts.Run.order_id.in_(order_ids)) + + # Filter by after/before datetime + after_str = query_args.get('after') + if after_str: + after_dt = parse_datetime(after_str) + if after_dt is None: + abort_with_error(400, "Invalid 'after' datetime format") + query = query.filter(ts.Run.start_time > after_dt) + + before_str = query_args.get('before') + if before_str: + before_dt = parse_datetime(before_str) + if before_dt is None: + abort_with_error(400, "Invalid 'before' datetime format") + query = query.filter(ts.Run.start_time < before_dt) + + # Sort: default is ascending by ID (insertion order). + sort = query_args.get('sort') + descending = (sort == '-start_time') + + cursor_str = query_args.get('cursor') + limit = query_args['limit'] + items, next_cursor = cursor_paginate( + query, ts.Run.id, cursor_str, limit, descending=descending) + + serialized = [serialize_run(run, ts) for run in items] + return jsonify(make_paginated_response(serialized, next_cursor)) + + @require_scope('submit') + @blp.arguments(RunSubmitQuerySchema, location="query") + @blp.response(201, RunSubmitResponseSchema) + def post(self, query_args, testsuite): + """Submit a new run. + + Accepts the LNT JSON report format (format_version '2' only). + Legacy formats (v0, v1) and non-JSON payloads (e.g. plist) + are rejected. A UUID is assigned to the run automatically. + + Regression detection is always skipped; create field changes + separately via POST /field-changes. + """ + reject_unknown_params({'on_machine_conflict', 'on_existing_run'}) + db = g.db + session = g.db_session + + data = request.get_data(as_text=True) + if not data or not data.strip(): + abort_with_error(400, "Request body must be a non-empty JSON payload") + + # Mandate JSON format with format_version '2' for the v5 API. + try: + parsed = json.loads(data) + except ValueError as exc: + abort_with_error(400, "Request body is not valid JSON: %s" % exc) + if not isinstance(parsed, dict): + abort_with_error(400, "Request body must be a JSON object, " + "not %s" % type(parsed).__name__) + version = parsed.get('format_version') + if version is None: + abort_with_error(400, "v5 API requires format_version '2', " + "but it is missing") + if version != '2': + abort_with_error(400, "v5 API requires format_version '2', " + "got %r" % (version,)) + + select_machine = _CONFLICT_MAP[query_args['on_machine_conflict']] + merge_run = _MERGE_MAP[query_args['on_existing_run']] + + result = lnt.util.ImportData.import_from_string( + current_app.old_config, g.db_name, db, session, + testsuite, data, + select_machine=select_machine, + merge_run=merge_run, + ignore_regressions=True, + ) + + error = result.get('error') + if error is not None: + abort_with_error(400, str(error)) + + # The import pipeline assigned a UUID in _getOrCreateRun(). + # Retrieve the run to get its UUID. + run_id = result.get('run_id') + if run_id is None: + abort_with_error(500, "Import succeeded but no run_id returned") + + # Re-query to get the UUID (the session may have committed already). + ts = db.testsuite.get(testsuite) + if ts is None: + abort_with_error(500, "Testsuite not found after import") + + run = session.query(ts.Run).filter(ts.Run.id == run_id).first() + if run is None: + abort_with_error(500, "Run not found after import") + + run_uuid = run.uuid + + result_url = '/api/v5/%s/runs/%s' % (testsuite, run_uuid) + + response = jsonify({ + 'success': True, + 'run_uuid': run_uuid, + 'result_url': result_url, + }) + response.status_code = 201 + response.headers['Location'] = result_url + return response + + +@blp.route('/runs/') +class RunDetail(MethodView): + """Run detail and deletion.""" + + @require_scope('read') + @blp.response(200, RunResponseSchema) + def get(self, testsuite, run_uuid): + """Get run detail by UUID.""" + reject_unknown_params(set()) + ts = g.ts + session = g.db_session + + run = session.query(ts.Run).options( + joinedload(ts.Run.machine), + joinedload(ts.Run.order), + ).filter(ts.Run.uuid == run_uuid).first() + + if run is None: + abort_with_error(404, "Run '%s' not found" % run_uuid) + + data = serialize_run(run, ts) + return add_etag_to_response(jsonify(data), data) + + @require_scope('manage') + @blp.response(204) + def delete(self, testsuite, run_uuid): + """Delete a run and all associated samples.""" + ts = g.ts + session = g.db_session + + run = session.query(ts.Run).filter( + ts.Run.uuid == run_uuid + ).first() + + if run is None: + abort_with_error(404, "Run '%s' not found" % run_uuid) + + session.delete(run) + session.flush() + + return make_response('', 204) diff --git a/lnt/server/api/v5/endpoints/samples.py b/lnt/server/api/v5/endpoints/samples.py new file mode 100644 index 000000000..16e60f48b --- /dev/null +++ b/lnt/server/api/v5/endpoints/samples.py @@ -0,0 +1,113 @@ +"""Sample endpoints for the v5 API. + +GET /api/v5/{ts}/runs/{uuid}/samples -- All samples for a run +GET /api/v5/{ts}/runs/{uuid}/tests/{test_name}/samples -- Samples for a test +""" + +from flask import g, jsonify +from flask.views import MethodView +from flask_smorest import Blueprint +from sqlalchemy.orm import joinedload + +from ..auth import require_scope +from ..errors import reject_unknown_params +from ..helpers import lookup_run_by_uuid, lookup_test +from ..pagination import ( + cursor_paginate, + make_paginated_response, +) +from ..schemas.samples import ( + PaginatedSampleResponseSchema, + RunSamplesQuerySchema, + SampleListResponseSchema, +) + +blp = Blueprint( + 'Samples', + __name__, + url_prefix='/api/v5/', + description='List metric measurements collected for each test in a run', +) + + +def _serialize_sample(sample, ts): + """Serialize a Sample model instance for the API response. + + Returns a dict with test_name, has_profile, and a metrics dict + containing all non-null sample field values. + """ + metrics = {} + for field in ts.sample_fields: + value = sample.get_field(field) + if value is not None: + metrics[field.name] = value + + return { + 'test': sample.test.name, + 'has_profile': sample.profile_id is not None, + 'metrics': metrics, + } + + +@blp.route('/runs//samples') +class RunSamples(MethodView): + """List all samples for a run.""" + + @require_scope('read') + @blp.arguments(RunSamplesQuerySchema, location="query") + @blp.response(200, PaginatedSampleResponseSchema) + def get(self, query_args, testsuite, run_uuid): + """List samples for a run (cursor-paginated).""" + reject_unknown_params({'has_profile', 'cursor', 'limit'}) + ts = g.ts + session = g.db_session + run = lookup_run_by_uuid(session, ts, run_uuid) + + query = session.query(ts.Sample).options( + joinedload(ts.Sample.test) + ).filter( + ts.Sample.run_id == run.id + ) + + # Apply has_profile filter + if query_args.get('has_profile') is True: + query = query.filter(ts.Sample.profile_id.isnot(None)) + + cursor_str = query_args.get('cursor') + limit = query_args['limit'] + items, next_cursor = cursor_paginate( + query, ts.Sample.id, cursor_str, limit) + + serialized = [_serialize_sample(s, ts) for s in items] + return jsonify(make_paginated_response(serialized, next_cursor)) + + +@blp.route('/runs//tests//samples') +class RunTestSamples(MethodView): + """List samples for a specific test in a run.""" + + @require_scope('read') + @blp.response(200, SampleListResponseSchema) + def get(self, testsuite, run_uuid, test_name): + """Get samples for a specific test in a run. + + Returns a list because a run may have multiple samples for the + same test. + """ + reject_unknown_params(set()) + ts = g.ts + session = g.db_session + run = lookup_run_by_uuid(session, ts, run_uuid) + + # Look up the test by name + test = lookup_test(session, ts, test_name) + + samples = session.query(ts.Sample).options( + joinedload(ts.Sample.test) + ).filter( + ts.Sample.run_id == run.id, + ts.Sample.test_id == test.id, + ).all() + + serialized = [_serialize_sample(s, ts) for s in samples] + return jsonify({'items': serialized}) diff --git a/lnt/server/api/v5/endpoints/test_suites.py b/lnt/server/api/v5/endpoints/test_suites.py new file mode 100644 index 000000000..8b2d52a79 --- /dev/null +++ b/lnt/server/api/v5/endpoints/test_suites.py @@ -0,0 +1,256 @@ +"""Test suite management endpoints for the v5 API. + +GET /api/v5/test-suites -- List all test suites +POST /api/v5/test-suites -- Create a test suite +GET /api/v5/test-suites/ -- Get suite details +DELETE /api/v5/test-suites/ -- Delete a test suite +""" + +from flask import after_this_request, g +from flask.views import MethodView +from flask_smorest import Blueprint + +from lnt.server.db import testsuite +import lnt.server.db.testsuitedb + +from ..auth import require_scope +from ..errors import abort_with_error, reject_unknown_params +from ..schemas.test_suites import ( + TestSuiteCreateQuerySchema, + TestSuiteCreateRequestSchema, + TestSuiteDeleteQuerySchema, + TestSuiteDetailQuerySchema, + TestSuiteDetailResponseSchema, + TestSuiteListQuerySchema, + TestSuiteListResponseSchema, +) + +blp = Blueprint( + 'Test Suites', + __name__, + url_prefix='/api/v5/test-suites', + description='List, create, and delete test suites and their field definitions', +) + + +def _suite_links(name): + """Build the standard per-suite links dict.""" + prefix = '/api/v5/%s' % name + return { + 'machines': prefix + '/machines', + 'orders': prefix + '/orders', + 'runs': prefix + '/runs', + 'tests': prefix + '/tests', + 'regressions': prefix + '/regressions', + 'field_changes': prefix + '/field-changes', + 'query': prefix + '/query', + } + + +def _suite_detail(db, name): + """Build a detail dict for a suite.""" + tsdb = db.testsuite[name] + return { + 'name': name, + 'schema': tsdb.test_suite.__json__(), + 'links': _suite_links(name), + } + + +@blp.route('/') +class TestSuiteCollection(MethodView): + """List and create test suites.""" + + @blp.arguments(TestSuiteListQuerySchema, location='query') + @blp.response(200, TestSuiteListResponseSchema) + def get(self, query_args): + """List all test suites.""" + reject_unknown_params(set()) + db = getattr(g, 'db', None) + if db is None: + return {'items': []} + + items = [] + for name in sorted(db.testsuite.keys()): + items.append(_suite_detail(db, name)) + return {'items': items} + + @require_scope('manage') + @blp.arguments(TestSuiteCreateQuerySchema, location='query') + @blp.arguments(TestSuiteCreateRequestSchema) + @blp.response(201, TestSuiteDetailResponseSchema) + def post(self, query_args, payload): + """Create a new test suite.""" + reject_unknown_params(set()) + db = g.db + session = g.db_session + name = payload['name'] + + # Check the in-memory cache first + if name in db.testsuite: + abort_with_error(409, "Test suite '%s' already exists" % name) + + # Also check the DB metatable to guard against races + existing = session.query(testsuite.TestSuite).filter( + testsuite.TestSuite.name == name + ).first() + if existing is not None: + abort_with_error(409, "Test suite '%s' already exists" % name) + + # Build the TestSuite object from the payload + try: + suite = testsuite.TestSuite.from_json(payload) + except (ValueError, AssertionError, KeyError) as exc: + abort_with_error(400, str(exc)) + + # All creation steps are wrapped so that if any step fails, + # metadata is rolled back and any created tables are dropped. + # This avoids the bug where an early commit persists metadata + # rows but a later failure (e.g. in create_tables) leaves the + # database in an inconsistent state with no corresponding tables. + tsdb = None + try: + # Stage metadata rows without committing. For a brand-new + # suite we add the JSON schema row directly instead of calling + # check_testsuite_schema_changes (which commits internally). + schema = testsuite.TestSuiteJSONSchema(name, suite.jsonschema) + session.add(schema) + suite = testsuite.sync_testsuite_with_metatables(session, suite) + session.flush() + + # Create physical per-suite tables (DDL). We pass the + # session's connection instead of the engine so that the + # CREATE TABLE statements execute within the same transaction + # (and on the same DB connection) as the flushed metadata + # inserts. Using a separate connection would deadlock on + # PostgreSQL because FieldChange has a FK to SampleField: + # connection A holds ROW EXCLUSIVE on TestSuiteSampleFields + # from the flush, while connection B's CREATE TABLE needs + # SHARE ROW EXCLUSIVE on that same table. + tsdb = lnt.server.db.testsuitedb.TestSuiteDB(db, name, suite) + tsdb.create_tables(session.connection()) + + # Bump registry version so other workers pick up the change. + db.increment_registry_version(session) + session.commit() + except Exception as exc: + session.rollback() + # Best-effort cleanup: drop tables that may have been created + # before the failure. + if tsdb is not None: + try: + tsdb.base.metadata.drop_all(db.engine) + except Exception: + pass + abort_with_error(400, + "Failed to create test suite '%s': %s" + % (name, exc)) + + db.testsuite[name] = tsdb + db.testsuite = dict(sorted(db.testsuite.items())) + + @after_this_request + def add_location_header(response): + response.headers['Location'] = '/api/v5/test-suites/%s' % name + return response + + return { + 'name': name, + 'schema': suite.__json__(), + 'links': _suite_links(name), + } + + +@blp.route('/') +class TestSuiteDetail(MethodView): + """Get or delete a test suite.""" + + @blp.arguments(TestSuiteDetailQuerySchema, location='query') + @blp.response(200, TestSuiteDetailResponseSchema) + def get(self, query_args, suite_name): + """Get a test suite's field definitions and resource links.""" + reject_unknown_params(set()) + db = getattr(g, 'db', None) + if db is None or suite_name not in db.testsuite: + abort_with_error(404, "Test suite '%s' not found" % suite_name) + return _suite_detail(db, suite_name) + + @require_scope('manage') + @blp.arguments(TestSuiteDeleteQuerySchema, location='query') + def delete(self, query_args, suite_name): + """Delete a test suite and all its data (irreversible). + + Requires ?confirm=true to proceed. + """ + reject_unknown_params({'confirm'}) + + confirm = query_args.get('confirm') + if confirm != 'true': + abort_with_error( + 400, + "Deleting a test suite drops all its tables and data. " + "Pass ?confirm=true to proceed.") + + db = g.db + session = g.db_session + + if suite_name not in db.testsuite: + abort_with_error(404, "Test suite '%s' not found" % suite_name) + + tsdb = db.testsuite[suite_name] + + # Deletion order is chosen for safety: metadata first, then tables, + # then in-memory dict. If metadata deletion fails, no tables are + # dropped and we can roll back cleanly. If table dropping fails + # *after* metadata is committed, we end up with orphaned tables + # (harmless) rather than metadata pointing at missing tables. + + # 1. Delete metadata rows and commit + try: + ts_row = session.query(testsuite.TestSuite).filter( + testsuite.TestSuite.name == suite_name + ).first() + if ts_row is not None: + ts_id = ts_row.id + # Null out self-referential FK before deleting SampleFields + session.query(testsuite.SampleField).filter( + testsuite.SampleField.test_suite_id == ts_id + ).update({testsuite.SampleField.status_field_id: None}, + synchronize_session='fetch') + session.flush() + + # Delete field rows + for model in (testsuite.SampleField, testsuite.MachineField, + testsuite.OrderField, testsuite.RunField): + session.query(model).filter( + model.test_suite_id == ts_id + ).delete(synchronize_session='fetch') + + # Delete JSON schema row + session.query(testsuite.TestSuiteJSONSchema).filter( + testsuite.TestSuiteJSONSchema.testsuite_name == suite_name + ).delete(synchronize_session='fetch') + + # Delete the TestSuite row itself + session.delete(ts_row) + + db.increment_registry_version(session) + session.commit() + except Exception as exc: + session.rollback() + abort_with_error( + 500, + "Failed to delete metadata for '%s': %s" % (suite_name, exc)) + + # 2. Drop per-suite tables (best-effort after metadata is gone) + try: + tsdb.base.metadata.drop_all(db.engine) + except Exception: + # Tables are orphaned but metadata is already gone — harmless. + # A future CREATE of the same suite will recreate them. + pass + + # 3. Remove from in-memory dict + del db.testsuite[suite_name] + + return '', 204 diff --git a/lnt/server/api/v5/endpoints/tests.py b/lnt/server/api/v5/endpoints/tests.py new file mode 100644 index 000000000..5ffe0eb5c --- /dev/null +++ b/lnt/server/api/v5/endpoints/tests.py @@ -0,0 +1,90 @@ +"""Test entity endpoints for the v5 API. + +GET /api/v5/{ts}/tests -- List tests (cursor-paginated, filterable) +GET /api/v5/{ts}/tests/{test_name} -- Test detail +""" + +from flask import g, jsonify +from flask.views import MethodView +from flask_smorest import Blueprint + +from ..auth import require_scope +from ..errors import reject_unknown_params +from ..etag import add_etag_to_response +from ..helpers import escape_like, lookup_test +from ..pagination import ( + cursor_paginate, + make_paginated_response, +) +from ..schemas.tests import ( + PaginatedTestResponseSchema, + TestListQuerySchema, + TestResponseSchema, +) + +blp = Blueprint( + 'Tests', + __name__, + url_prefix='/api/v5/', + description='List and inspect test definitions', +) + + +def _serialize_test(test): + """Serialize a Test model instance for the API response.""" + return {'name': test.name} + + +@blp.route('/tests') +class TestList(MethodView): + """List tests.""" + + @require_scope('read') + @blp.arguments(TestListQuerySchema, location="query") + @blp.response(200, PaginatedTestResponseSchema) + def get(self, query_args, testsuite): + """List tests (cursor-paginated, filterable).""" + reject_unknown_params({'name_contains', 'name_prefix', 'cursor', 'limit'}) + ts = g.ts + session = g.db_session + + query = session.query(ts.Test) + + # Apply filters + name_contains = query_args.get('name_contains') + if name_contains: + escaped = escape_like(name_contains) + query = query.filter( + ts.Test.name.like('%' + escaped + '%', escape='\\')) + + name_prefix = query_args.get('name_prefix') + if name_prefix: + escaped = escape_like(name_prefix) + query = query.filter( + ts.Test.name.like(escaped + '%', escape='\\')) + + cursor_str = query_args.get('cursor') + limit = query_args['limit'] + items, next_cursor = cursor_paginate( + query, ts.Test.id, cursor_str, limit) + + serialized = [_serialize_test(t) for t in items] + return jsonify(make_paginated_response(serialized, next_cursor)) + + +@blp.route('/tests/') +class TestDetail(MethodView): + """Test detail.""" + + @require_scope('read') + @blp.response(200, TestResponseSchema) + def get(self, testsuite, test_name): + """Get test detail by name. Test names may contain slashes.""" + reject_unknown_params(set()) + ts = g.ts + session = g.db_session + + test = lookup_test(session, ts, test_name) + + data = _serialize_test(test) + return add_etag_to_response(jsonify(data), data) diff --git a/lnt/server/api/v5/errors.py b/lnt/server/api/v5/errors.py new file mode 100644 index 000000000..3b2d48367 --- /dev/null +++ b/lnt/server/api/v5/errors.py @@ -0,0 +1,216 @@ +"""Standardized error handling scoped to the v5 API. + +Produces responses in the format: + {"error": {"code": "not_found", "message": "Machine 'foo' not found"}} + +Error handlers are registered on the flask-smorest Api / Flask app but only +apply to v5 API paths to avoid breaking v4 error format. + +IMPORTANT: ``register_error_handlers`` must be called AFTER any app-level +error handlers (e.g. the 404/500 handlers in ``app.py``) so that we can +save and delegate to them for non-v5 routes. +""" + +import logging + +from flask import jsonify, request +from werkzeug.exceptions import HTTPException + +logger = logging.getLogger(__name__) + + +# Map HTTP status codes to error code strings +STATUS_CODE_MAP = { + 400: 'validation_error', + 401: 'unauthorized', + 403: 'forbidden', + 404: 'not_found', + 405: 'method_not_allowed', + 409: 'conflict', + 415: 'unsupported_media_type', + 422: 'validation_error', + 429: 'rate_limited', + 500: 'internal_error', +} + + +class V5ApiError(Exception): + """Custom exception for v5 API errors. + + Raised by ``abort_with_error`` and caught by a Flask error handler + registered in ``register_error_handlers``. This replaces the previous + ``flask.abort(response)`` pattern which relied on Flask's undocumented + behaviour of passing through Response objects wrapped in an HTTPException + with ``code=None``. + """ + + def __init__(self, status_code, error_code, message): + super().__init__(message) + self.status_code = status_code + self.error_code = error_code + self.message = message + + +def _make_error_response(code, message, status_code): + """Build a standardized error JSON response.""" + resp = jsonify({ + 'error': { + 'code': code, + 'message': message, + } + }) + resp.status_code = status_code + return resp + + +def _get_previous_handler(app, code): + """Return the previously registered error handler for *code*, or None. + + Flask stores app-level handlers in + ``app.error_handler_spec[None][code]``. We look up the handler for + the given integer status code (or ``None`` for exception-class-keyed + handlers). + """ + spec = app.error_handler_spec.get(None, {}) + handlers = spec.get(code, {}) + if not handlers: + return None + # The dict is keyed by exception class; return the first (there is + # usually only one per code). + for handler in handlers.values(): + return handler + return None + + +def _non_v5_fallback(exc, previous_handler): + """Handle *exc* on a non-v5 route. + + If a *previous_handler* (the one that was registered before v5's) + exists, delegate to it so that app-level error formatting (e.g. + the content-negotiating 404/500 handlers in ``app.py``) is + preserved. Otherwise fall back to werkzeug's default HTML + response — which is exactly what Flask itself does when no error + handler is registered. + """ + if previous_handler is not None: + return previous_handler(exc) + return exc.get_response() + + +def register_error_handlers(smorest_api, app): + """Register error handlers scoped to v5 API paths. + + We register on the Flask app itself, but the handlers check + ``request.path`` so they only transform responses for ``/api/v5/`` + routes. For non-v5 routes the previously registered handler (if + any) is called, preserving v4 / Flask-RESTful error formatting. + + This function MUST be called after any app-level error handlers + (404, 500, etc.) have been registered, so that the saved + ``previous_handler`` references are valid. + """ + + @app.errorhandler(V5ApiError) + def handle_v5_api_error(exc): + return _make_error_response(exc.error_code, exc.message, + exc.status_code) + + # -- HTTPException (generic) ------------------------------------------ + prev_http = _get_previous_handler(app, None) + + @app.errorhandler(HTTPException) + def handle_http_exception(exc): + if not request.path.startswith('/api/v5/'): + if prev_http is not None: + return prev_http(exc) + return exc.get_response() + + status_code = exc.code or 500 + error_code = STATUS_CODE_MAP.get(status_code, 'error') + message = exc.description or str(exc) + + return _make_error_response(error_code, message, status_code) + + # -- 422 Unprocessable Entity (webargs validation) -------------------- + prev_422 = _get_previous_handler(app, 422) + + @app.errorhandler(422) + def handle_unprocessable(exc): + if not request.path.startswith('/api/v5/'): + return _non_v5_fallback(exc, prev_422) + + # flask-smorest/webargs validation errors include details + messages = getattr(exc, 'data', {}).get('messages', {}) + if messages: + detail = str(messages) + else: + detail = getattr(exc, 'description', str(exc)) + + return _make_error_response('validation_error', detail, 422) + + # -- Per-status-code handlers ----------------------------------------- + # Register explicit handlers for common status codes so that they take + # priority over the app-level 404/500 handlers registered in app.py. + # Flask dispatches to the most-specific (by status code) handler, so a + # generic HTTPException handler alone is not enough. + for _code in (400, 401, 403, 404, 405, 409, 500): + def _make_handler(code, previous_handler): + def _handler(exc): + if not request.path.startswith('/api/v5/'): + return _non_v5_fallback(exc, previous_handler) + error_code = STATUS_CODE_MAP.get(code, 'error') + message = getattr(exc, 'description', str(exc)) + return _make_error_response(error_code, message, code) + _handler.__name__ = 'handle_v5_%d' % code + return _handler + _prev = _get_previous_handler(app, _code) + app.errorhandler(_code)(_make_handler(_code, _prev)) + + # -- Generic Exception handler ---------------------------------------- + @app.errorhandler(Exception) + def handle_generic_exception(exc): + # V5ApiError is handled by its own dedicated handler above. + if isinstance(exc, V5ApiError): + return handle_v5_api_error(exc) + + if not request.path.startswith('/api/v5/'): + if isinstance(exc, HTTPException): + # Delegate to the per-code or generic HTTP handler so that + # app-level formatting is preserved. + return handle_http_exception(exc) + raise exc + + # If it is an HTTPException, delegate to the HTTP handler + if isinstance(exc, HTTPException): + return handle_http_exception(exc) + + logger.exception("Unhandled exception in v5 API") + return _make_error_response('internal_error', + 'An unexpected error occurred.', 500) + + +def abort_with_error(status_code, message): + """Abort the current request with a standardized v5 error response. + + Raises a :class:`V5ApiError` which is caught by the handler registered + in :func:`register_error_handlers` and converted into a JSON response. + """ + error_code = STATUS_CODE_MAP.get(status_code, 'error') + raise V5ApiError(status_code, error_code, message) + + +def reject_unknown_params(valid_params): + """Reject any query parameters not in *valid_params*. + + Call at the top of every GET/POST handler that reads ``request.args`` + so that typos like ``name_contain=foo`` instead of ``name_contains=foo`` + are caught early (400) rather than silently returning unfiltered data. + """ + unknown = set(request.args.keys()) - valid_params + if unknown: + abort_with_error( + 400, + "Unknown query parameter(s): %s. " + "Valid parameters are: %s" + % (', '.join(sorted(unknown)), + ', '.join(sorted(valid_params)))) diff --git a/lnt/server/api/v5/etag.py b/lnt/server/api/v5/etag.py new file mode 100644 index 000000000..c870e52d5 --- /dev/null +++ b/lnt/server/api/v5/etag.py @@ -0,0 +1,66 @@ +"""ETag computation and conditional request support for the v5 API. + +Uses weak ETags (``W/""``) computed from the JSON-serialized response +body. Checks ``If-None-Match`` and returns 304 when appropriate. +""" + +import hashlib +import json + +from flask import request + + +def compute_etag(data): + """Compute a weak ETag from a Python object (dict/list). + + The object is serialized to compact JSON and hashed with MD5. + """ + serialized = json.dumps(data, sort_keys=True, separators=(',', ':')) + md5 = hashlib.md5(serialized.encode('utf-8')).hexdigest() + return 'W/"%s"' % md5 + + +def check_etag(etag_value): + """Check ``If-None-Match`` against the given ETag. + + Returns a 304 Not Modified response if the client already has the + current version, otherwise returns None. + """ + if_none_match = request.headers.get('If-None-Match', '') + if not if_none_match: + return None + + # Parse comma-separated ETags per RFC 7232 + client_etags = [e.strip() for e in if_none_match.split(',')] + # Normalise: strip W/ prefix for comparison + + def normalise(e): + if e.startswith('W/'): + return e[2:] + return e + + normalised_server = normalise(etag_value) + for client_etag in client_etags: + if client_etag == '*' or normalise(client_etag) == normalised_server: + from flask import Response + resp = Response(status=304) + resp.headers['ETag'] = etag_value + return resp + + return None + + +def add_etag_to_response(response, data): + """Compute an ETag from *data* and set it on *response*. + + Also checks ``If-None-Match``. If the client already has the + current version, returns a 304 response instead. + """ + etag_value = compute_etag(data) + + not_modified = check_etag(etag_value) + if not_modified is not None: + return not_modified + + response.headers['ETag'] = etag_value + return response diff --git a/lnt/server/api/v5/helpers.py b/lnt/server/api/v5/helpers.py new file mode 100644 index 000000000..09fc80c1b --- /dev/null +++ b/lnt/server/api/v5/helpers.py @@ -0,0 +1,216 @@ +"""Shared helper functions for v5 API endpoints.""" + +import datetime + +from .errors import abort_with_error + + +def parse_datetime(value): + """Parse an ISO datetime string. Returns a naive datetime or None. + + Two differences from ``datetime.fromisoformat``: + + 1. Accepts ``Z`` as a timezone suffix (mapped to ``+00:00``). + 2. Always returns a **naive** datetime (tzinfo stripped) because + the database stores naive UTC timestamps. + """ + if not value: + return None + try: + dt = datetime.datetime.fromisoformat(value.replace('Z', '+00:00')) + # Strip timezone info for naive comparison (DB stores naive datetimes) + if dt.tzinfo is not None: + dt = dt.astimezone(datetime.timezone.utc).replace(tzinfo=None) + return dt + except (ValueError, TypeError): + return None + + +def escape_like(pattern): + """Escape SQL LIKE wildcards in user-supplied patterns.""" + return pattern.replace('\\', '\\\\').replace('%', r'\%').replace('_', r'\_') + + +def validate_tag(tag): + """Validate and normalize a tag value. + + Returns the normalized tag (None for empty strings) or aborts with + 400 if the value is invalid. + """ + if tag is not None and (not isinstance(tag, str) or len(tag) > 64): + abort_with_error(400, "'tag' must be a string of at most 64 characters") + return tag or None + + +def resolve_metric(ts, field_name): + """Resolve a metric name to its SampleField object. + + Searches the test suite's cached ``sample_fields`` list for a field + whose name matches *field_name*. Returns the :class:`SampleField` on + success, or aborts with a 400 error if no match is found. + """ + for sf in ts.sample_fields: + if sf.name == field_name: + return sf + abort_with_error(400, "Unknown metric name '%s'" % field_name) + + +# --------------------------------------------------------------------------- +# Entity lookup helpers (abort with 404 if not found) +# --------------------------------------------------------------------------- + +def lookup_machine(session, ts, machine_name): + """Look up a machine by name. + + Returns the machine, or aborts with 404 if not found, or 409 if + multiple machines share the same name. + """ + machines = session.query(ts.Machine).filter( + ts.Machine.name == machine_name + ).all() + if len(machines) == 0: + abort_with_error(404, "Machine '%s' not found" % machine_name) + if len(machines) > 1: + ids = ', '.join(str(m.id) for m in machines) + abort_with_error( + 409, + "Multiple machines named '%s' exist (IDs: %s). " + "Use the v4 UI to merge or rename them." % (machine_name, ids)) + return machines[0] + + +def lookup_run_by_uuid(session, ts, run_uuid): + """Look up a Run by UUID. Aborts with 404 if not found.""" + run = session.query(ts.Run).filter( + ts.Run.uuid == run_uuid + ).first() + if run is None: + abort_with_error(404, "Run '%s' not found" % run_uuid) + return run + + +def lookup_fieldchange(session, ts, fc_uuid): + """Look up a FieldChange by UUID. Aborts with 404 if not found.""" + fc = session.query(ts.FieldChange).filter( + ts.FieldChange.uuid == fc_uuid + ).first() + if fc is None: + abort_with_error(404, "Field change '%s' not found" % fc_uuid) + return fc + + +def lookup_test(session, ts, test_name): + """Look up a Test by name. Aborts with 404 if not found.""" + test = session.query(ts.Test).filter( + ts.Test.name == test_name + ).first() + if test is None: + abort_with_error(404, "Test '%s' not found" % test_name) + return test + + +def lookup_regression(session, ts, regression_uuid): + """Look up a Regression by UUID. Aborts with 404 if not found.""" + regression = session.query(ts.Regression).filter( + ts.Regression.uuid == regression_uuid + ).first() + if regression is None: + abort_with_error(404, "Regression '%s' not found" % regression_uuid) + return regression + + +# --------------------------------------------------------------------------- +# Serialization helpers +# --------------------------------------------------------------------------- + +def serialize_run(run, ts): + """Serialize a Run model instance for API responses. + + Returns a dict with uuid, machine, order, start_time, end_time, + and parameters. Used by both the runs and machines endpoints. + """ + # Build order dict from order fields + order_dict = {} + if run.order: + for field in run.order.fields: + val = run.order.get_field(field) + if val is not None: + order_dict[field.name] = str(val) + + start_time = None + if run.start_time: + start_time = run.start_time.isoformat() + end_time = None + if run.end_time: + end_time = run.end_time.isoformat() + + # Machine name + machine_name = None + if run.machine: + machine_name = run.machine.name + + # Run parameters + parameters = {} + try: + params = run.parameters + if params: + for k, v in params.items(): + parameters[k] = str(v) + except (TypeError, ValueError): + pass + + return { + 'uuid': run.uuid, + 'machine': machine_name, + 'order': order_dict, + 'start_time': start_time, + 'end_time': end_time, + 'parameters': parameters, + } + + +def serialize_fieldchange(fc): + """Serialize the common fields of a FieldChange for API responses. + + Returns a dict with test, machine, metric, old_value, new_value, + start_order, end_order, and run_uuid. Callers should add an + identifier key (``uuid`` or ``field_change_uuid``) to the result + before returning it to the client. + """ + # Get field name from the SampleField relation + field_name = None + if fc.field is not None: + field_name = fc.field.name + + # Get order field values + start_order_val = None + if fc.start_order is not None: + for field in fc.start_order.fields: + val = fc.start_order.get_field(field) + if val is not None: + start_order_val = str(val) + break + + end_order_val = None + if fc.end_order is not None: + for field in fc.end_order.fields: + val = fc.end_order.get_field(field) + if val is not None: + end_order_val = str(val) + break + + # Get run UUID + run_uuid = None + if fc.run is not None: + run_uuid = fc.run.uuid + + return { + 'test': fc.test.name if fc.test else None, + 'machine': fc.machine.name if fc.machine else None, + 'metric': field_name, + 'old_value': fc.old_value, + 'new_value': fc.new_value, + 'start_order': start_order_val, + 'end_order': end_order_val, + 'run_uuid': run_uuid, + } diff --git a/lnt/server/api/v5/middleware.py b/lnt/server/api/v5/middleware.py new file mode 100644 index 000000000..86961a290 --- /dev/null +++ b/lnt/server/api/v5/middleware.py @@ -0,0 +1,138 @@ +"""v5 API middleware: testsuite resolution, DB session lifecycle, CORS, +and access logging.""" + +import datetime +import logging +import sys + +from flask import current_app, g, jsonify, request + +access_logger = logging.getLogger('lnt.server.api.v5.access') + + +def register_middleware(app): + """Register before_request and after_request hooks for /api/v5/ paths.""" + + # Configure access logger (once, even if called multiple times in tests). + if not access_logger.handlers: + handler = logging.StreamHandler(sys.stderr) + handler.setLevel(logging.INFO) + handler.setFormatter(logging.Formatter('%(message)s')) + access_logger.addHandler(handler) + access_logger.setLevel(logging.INFO) + access_logger.propagate = False + + @app.before_request + def v5_before_request(): + """Open a DB session for v5 API requests and resolve the testsuite.""" + if not request.path.startswith('/api/v5/'): + return + + # Skip DB setup for OpenAPI spec paths + if request.path.startswith('/api/v5/openapi'): + return + + # Always open a DB session for v5 paths (needed for auth, discovery, etc.) + db = current_app.instance.get_database("default") + if db is None: + return + g.db = db + g.db_name = "default" + g.db_session = db.make_session() + + # Check whether another worker has created/deleted a suite. + db.check_registry_version(g.db_session) + + # Resolve testsuite from view_args if the URL contains one. + # Discovery (/api/v5/) and admin (/api/v5/admin/) paths have no + # testsuite in the URL. + view_args = request.view_args or {} + testsuite = view_args.get('testsuite') + if testsuite: + if testsuite not in db.testsuite: + # Return a proper JSON error directly from middleware, + # avoiding the v4 HTML error handler. + resp = jsonify({ + 'error': { + 'code': 'not_found', + 'message': "Test suite '%s' not found" % testsuite, + } + }) + resp.status_code = 404 + return resp + g.ts = db.testsuite[testsuite] + + @app.teardown_request + def v5_teardown_request(exc): + """Close the DB session after the request.""" + session = g.pop('db_session', None) + if session is not None: + try: + if exc is not None: + session.rollback() + else: + session.commit() + except Exception: + session.rollback() + finally: + session.close() + + @app.after_request + def v5_cors_headers(response): + """Add CORS headers to v5 API responses.""" + if not request.path.startswith('/api/v5/'): + return response + + response.headers['Access-Control-Allow-Origin'] = '*' + response.headers['Access-Control-Allow-Methods'] = \ + 'GET, POST, PATCH, DELETE, OPTIONS' + response.headers['Access-Control-Allow-Headers'] = \ + 'Authorization, Content-Type, If-None-Match' + response.headers['Access-Control-Expose-Headers'] = 'ETag, Location' + response.headers['Access-Control-Max-Age'] = '86400' + + return response + + @app.after_request + def v5_access_log(response): + """Emit an Apache combined-format access log line for v5 requests.""" + if not request.path.startswith('/api/v5/'): + return response + + # Determine authenticated user from cached auth context. + scope, api_key = getattr(g, '_v5_auth', (None, None)) + if api_key is not None: + user = api_key.name + elif scope is not None: + user = 'bootstrap' + else: + user = '-' + + now = datetime.datetime.utcnow() + timestamp = now.strftime('%d/%b/%Y:%H:%M:%S +0000') + + content_length = response.content_length + size = str(content_length) if content_length is not None else '-' + + referer = request.headers.get('Referer', '-') + user_agent = request.headers.get('User-Agent', '-') + + path = request.full_path + if path.endswith('?'): + path = path[:-1] + + line = '%s - %s [%s] "%s %s %s" %d %s "%s" "%s"' % ( + request.remote_addr or '-', + user, + timestamp, + request.method, + path, + request.environ.get('SERVER_PROTOCOL', 'HTTP/1.1'), + response.status_code, + size, + referer, + user_agent, + ) + access_logger.info(line) + + return response diff --git a/lnt/server/api/v5/pagination.py b/lnt/server/api/v5/pagination.py new file mode 100644 index 000000000..2a63ae782 --- /dev/null +++ b/lnt/server/api/v5/pagination.py @@ -0,0 +1,115 @@ +"""Cursor-based and offset pagination utilities for the v5 API. + +Cursor-based pagination encodes the last-seen primary key as base64. +Forward-only in v1 (``previous`` is always null). + +Response envelope: + {"items": [...], "cursor": {"next": "...", "previous": null}} +""" + +import base64 + + +def encode_cursor(value): + """Encode an integer ID into a base64 cursor string.""" + return base64.urlsafe_b64encode(str(value).encode('utf-8')).decode('ascii') + + +def decode_cursor(cursor_str): + """Decode a base64 cursor string back into an integer ID. + + Returns None if the cursor is malformed. + """ + if not cursor_str: + return None + try: + decoded = base64.urlsafe_b64decode(cursor_str.encode('ascii')) + return int(decoded.decode('utf-8')) + except (ValueError, TypeError, UnicodeDecodeError): + return None + + +def cursor_paginate(query, id_column, cursor_str=None, limit=25, + descending=False): + """Apply cursor-based pagination to a SQLAlchemy query. + + Parameters + ---------- + query : sqlalchemy.orm.Query + The base query to paginate. Callers should **not** apply their + own ``.order_by()`` for the paginated column -- this function + handles ordering. + id_column : sqlalchemy.Column + The column used for ordering and cursor position (usually `Model.id`). + cursor_str : str or None + The cursor from the previous response (``cursor.next``). + limit : int + Maximum number of items to return. + descending : bool + When *True*, order by ``id_column DESC`` and page forward with + ``id_column < last_id``. Default is ascending order. + + Returns + ------- + (items, next_cursor) : (list, str or None) + The page of results and the cursor for the next page (or None if + there are no more results). + """ + if limit < 1: + limit = 1 + if limit > 500: + limit = 500 + + if cursor_str: + last_id = decode_cursor(cursor_str) + if last_id is None: + from flask import abort + abort(400, description="Invalid pagination cursor") + if descending: + query = query.filter(id_column < last_id) + else: + query = query.filter(id_column > last_id) + + if descending: + query = query.order_by(id_column.desc()) + else: + query = query.order_by(id_column.asc()) + + # Fetch one extra to detect if there is a next page. + items = query.limit(limit + 1).all() + + if len(items) > limit: + items = items[:limit] + next_cursor = encode_cursor(getattr(items[-1], id_column.key)) + else: + next_cursor = None + + return items, next_cursor + + +def make_paginated_response(items, next_cursor, total=None): + """Build the standard paginated response envelope. + + Parameters + ---------- + items : list + The serialized items for this page. + next_cursor : str or None + Cursor string for the next page. + total : int or None + Total count (included for offset-based pagination). + + Returns + ------- + dict + """ + result = { + 'items': items, + 'cursor': { + 'next': next_cursor, + 'previous': None, # Forward-only in v1 + }, + } + if total is not None: + result['total'] = total + return result diff --git a/lnt/server/api/v5/schemas/__init__.py b/lnt/server/api/v5/schemas/__init__.py new file mode 100644 index 000000000..82049afe1 --- /dev/null +++ b/lnt/server/api/v5/schemas/__init__.py @@ -0,0 +1,19 @@ +"""Base schema utilities for the v5 API. + +Provides a common base class and helpers for building marshmallow schemas +that work with flask-smorest and LNT's dynamic test-suite models. +""" + +import marshmallow as ma + + +class BaseSchema(ma.Schema): + """Common base for all v5 API schemas. + + Configured to: + - Raise on unknown fields by default + - Use ``ordered`` output for consistent JSON + """ + + class Meta: + ordered = True diff --git a/lnt/server/api/v5/schemas/admin.py b/lnt/server/api/v5/schemas/admin.py new file mode 100644 index 000000000..ca3b9b577 --- /dev/null +++ b/lnt/server/api/v5/schemas/admin.py @@ -0,0 +1,83 @@ +"""Marshmallow schemas for the Admin / API Key endpoints. + +Schemas: +- APIKeyCreateRequestSchema -- POST request body (name, scope) +- APIKeyCreateResponseSchema -- POST response (raw key shown once, prefix, scope) +- APIKeyItemSchema -- Item in list response (prefix, name, scope, etc.) +- APIKeyListResponseSchema -- GET list response +""" + +import marshmallow as ma + +from . import BaseSchema +from ..auth import SCOPE_LEVELS + + +def _validate_scope(value): + """Validate that the scope string is one of the known scope names.""" + if value not in SCOPE_LEVELS: + raise ma.ValidationError( + "Invalid scope '%s'. Must be one of: %s" + % (value, ', '.join(sorted(SCOPE_LEVELS.keys(), + key=lambda s: SCOPE_LEVELS[s]))) + ) + + +class APIKeyCreateRequestSchema(BaseSchema): + """Request body for POST /api/v5/admin/api-keys.""" + + name = ma.fields.String( + required=True, + metadata={'description': 'Human-readable name for the API key'}, + ) + scope = ma.fields.String( + required=True, + validate=_validate_scope, + metadata={ + 'description': 'Scope level: read, submit, triage, manage, admin', + }, + ) + + +class APIKeyCreateResponseSchema(BaseSchema): + """Response for POST /api/v5/admin/api-keys. + + The raw ``key`` value is shown exactly once and is never stored in + plaintext. + """ + + key = ma.fields.String( + required=True, + metadata={'description': 'Raw API key token (shown once)'}, + ) + prefix = ma.fields.String( + required=True, + metadata={'description': 'First 8 characters of the token (used as identifier)'}, + ) + scope = ma.fields.String( + required=True, + metadata={'description': 'Granted scope level'}, + ) + + +class APIKeyItemSchema(BaseSchema): + """Schema for a single API key in the list response. + + Never includes the key hash or the raw token. + """ + + prefix = ma.fields.String(required=True) + name = ma.fields.String(required=True) + scope = ma.fields.String(required=True) + created_at = ma.fields.DateTime(required=True) + last_used_at = ma.fields.DateTime(allow_none=True) + is_active = ma.fields.Boolean(required=True) + + +class APIKeyListResponseSchema(BaseSchema): + """Response for GET /api/v5/admin/api-keys.""" + + items = ma.fields.List( + ma.fields.Nested(APIKeyItemSchema), + required=True, + ) diff --git a/lnt/server/api/v5/schemas/common.py b/lnt/server/api/v5/schemas/common.py new file mode 100644 index 000000000..326a5295a --- /dev/null +++ b/lnt/server/api/v5/schemas/common.py @@ -0,0 +1,134 @@ +"""Common schemas used across v5 API endpoints: error responses, pagination +envelopes, and field metadata schemas. +""" + +import marshmallow as ma + +from . import BaseSchema + + +# --------------------------------------------------------------------------- +# Error schemas +# --------------------------------------------------------------------------- + +class ErrorDetailSchema(BaseSchema): + code = ma.fields.String(required=True, + metadata={'description': 'Machine-readable error code'}) + message = ma.fields.String(required=True, + metadata={'description': 'Human-readable error description'}) + + +class ErrorResponseSchema(BaseSchema): + error = ma.fields.Nested(ErrorDetailSchema, required=True) + + +# --------------------------------------------------------------------------- +# Pagination schemas +# --------------------------------------------------------------------------- + +class CursorSchema(BaseSchema): + next = ma.fields.String(allow_none=True, load_default=None, + metadata={'description': 'Cursor for the next page'}) + previous = ma.fields.String(allow_none=True, load_default=None, + metadata={'description': 'Reserved for future use (always null)'}) + + +class PaginatedResponseSchema(BaseSchema): + """Base envelope for paginated list responses. + + Subclasses should add an ``items`` field with the appropriate nested + schema. + """ + cursor = ma.fields.Nested(CursorSchema) + total = ma.fields.Integer(allow_none=True, load_default=None, + metadata={'description': 'Total count (for bounded lists)'}) + + +# --------------------------------------------------------------------------- +# Field metadata schemas +# --------------------------------------------------------------------------- + +class TestSuiteLinksSchema(BaseSchema): + """Links to resources within a test suite.""" + machines = ma.fields.String() + orders = ma.fields.String() + runs = ma.fields.String() + tests = ma.fields.String() + regressions = ma.fields.String() + field_changes = ma.fields.String() + query = ma.fields.String() + + +class TestSuiteDiscoverySchema(BaseSchema): + """A single test suite in the discovery response.""" + name = ma.fields.String(required=True) + links = ma.fields.Nested(TestSuiteLinksSchema, required=True) + + +class DiscoveryLinksSchema(BaseSchema): + """Top-level links in the discovery response.""" + openapi = ma.fields.String() + swagger_ui = ma.fields.String() + test_suites = ma.fields.String() + + +class DiscoveryResponseSchema(BaseSchema): + """Response schema for GET /api/v5/.""" + test_suites = ma.fields.List(ma.fields.Nested(TestSuiteDiscoverySchema)) + links = ma.fields.Nested(DiscoveryLinksSchema) + + +# --------------------------------------------------------------------------- +# Field change ignore response schema +# --------------------------------------------------------------------------- + +class FieldChangeIgnoreResponseSchema(BaseSchema): + """Response schema for POST /api/v5/{ts}/field-changes/{uuid}/ignore.""" + status = ma.fields.String( + required=True, + metadata={'description': 'Result status (e.g. "ignored")'}, + ) + field_change_uuid = ma.fields.String( + required=True, + metadata={'description': 'UUID of the ignored field change'}, + ) + + +# --------------------------------------------------------------------------- +# Query parameter schemas +# --------------------------------------------------------------------------- + +class BaseQuerySchema(BaseSchema): + """Base class for query parameter schemas. + + Sets ``unknown = EXCLUDE`` so that marshmallow ignores unknown + parameters (they are still rejected by ``reject_unknown_params``). + """ + + class Meta: + ordered = True + unknown = ma.EXCLUDE + + +class CursorPaginationQuerySchema(BaseQuerySchema): + """Query parameters for cursor-paginated endpoints.""" + cursor = ma.fields.String( + load_default=None, + metadata={'description': 'Pagination cursor from a previous response'}, + ) + limit = ma.fields.Integer( + load_default=25, + metadata={'description': 'Maximum number of results per page (default 25, max 500)'}, + ) + + +class OffsetPaginationQuerySchema(BaseQuerySchema): + """Query parameters for offset-paginated endpoints.""" + limit = ma.fields.Integer( + load_default=25, + metadata={'description': 'Maximum number of results per page (default 25, max 500)'}, + ) + offset = ma.fields.Integer( + load_default=0, + metadata={'description': 'Number of results to skip (default 0)'}, + ) diff --git a/lnt/server/api/v5/schemas/machines.py b/lnt/server/api/v5/schemas/machines.py new file mode 100644 index 000000000..596e2e28a --- /dev/null +++ b/lnt/server/api/v5/schemas/machines.py @@ -0,0 +1,130 @@ +"""Marshmallow schemas for machine request/response in the v5 API.""" + +import marshmallow as ma + +from . import BaseSchema +from .common import CursorPaginationQuerySchema, OffsetPaginationQuerySchema, PaginatedResponseSchema + + +# --------------------------------------------------------------------------- +# Request schemas +# --------------------------------------------------------------------------- + +class MachineCreateSchema(BaseSchema): + """Schema for POST /machines request body.""" + name = ma.fields.String( + required=True, + validate=ma.validate.Length(min=1), + metadata={'description': 'Machine name'}, + ) + info = ma.fields.Dict( + keys=ma.fields.String(), + values=ma.fields.String(), + load_default=None, + metadata={ + 'description': 'Optional key-value metadata for the machine', + 'example': {'os': 'linux', 'cpu': 'x86_64'}, + }, + ) + + +class MachineUpdateSchema(BaseSchema): + """Schema for PATCH /machines/{machine_name} request body.""" + name = ma.fields.String( + load_default=None, + validate=ma.validate.Length(min=1), + metadata={'description': 'New machine name (rename)'}, + ) + info = ma.fields.Dict( + keys=ma.fields.String(), + values=ma.fields.String(), + load_default=None, + metadata={ + 'description': 'Updated key-value metadata', + 'example': {'os': 'linux', 'cpu': 'x86_64'}, + }, + ) + + +# --------------------------------------------------------------------------- +# Response schemas +# --------------------------------------------------------------------------- + +class MachineResponseSchema(BaseSchema): + """Schema for a single machine in responses.""" + name = ma.fields.String(required=True) + info = ma.fields.Dict( + keys=ma.fields.String(), + values=ma.fields.String(), + metadata={ + 'description': 'Machine metadata / parameters', + 'example': {'os': 'linux', 'cpu': 'x86_64'}, + }, + ) + + +class MachineRunResponseSchema(BaseSchema): + """Schema for a run in the machine runs sub-resource.""" + uuid = ma.fields.String(required=True) + order = ma.fields.Dict( + keys=ma.fields.String(), + values=ma.fields.String(), + metadata={ + 'description': 'Order field values', + 'example': {'llvm_project_revision': 'abc123'}, + }, + ) + start_time = ma.fields.String( + allow_none=True, + metadata={'description': 'Run start time (ISO 8601)'}, + ) + end_time = ma.fields.String( + allow_none=True, + metadata={'description': 'Run end time (ISO 8601)'}, + ) + + +# --------------------------------------------------------------------------- +# Paginated response schemas +# --------------------------------------------------------------------------- + +class PaginatedMachineResponseSchema(PaginatedResponseSchema): + """Paginated list of machines.""" + items = ma.fields.List(ma.fields.Nested(MachineResponseSchema)) + + +class PaginatedMachineRunResponseSchema(PaginatedResponseSchema): + """Paginated list of machine runs.""" + items = ma.fields.List(ma.fields.Nested(MachineRunResponseSchema)) + + +# --------------------------------------------------------------------------- +# Query parameter schemas +# --------------------------------------------------------------------------- + +class MachineListQuerySchema(OffsetPaginationQuerySchema): + """Query parameters for GET /machines.""" + name_contains = ma.fields.String( + load_default=None, + metadata={'description': 'Filter by substring in machine name'}, + ) + name_prefix = ma.fields.String( + load_default=None, + metadata={'description': 'Filter by machine name prefix'}, + ) + + +class MachineRunsQuerySchema(CursorPaginationQuerySchema): + """Query parameters for GET /machines/{name}/runs.""" + after = ma.fields.String( + load_default=None, + metadata={'description': 'ISO datetime, only runs started after this time'}, + ) + before = ma.fields.String( + load_default=None, + metadata={'description': 'ISO datetime, only runs started before this time'}, + ) + sort = ma.fields.String( + load_default=None, + metadata={'description': 'Sort order. Use -start_time for newest first'}, + ) diff --git a/lnt/server/api/v5/schemas/orders.py b/lnt/server/api/v5/schemas/orders.py new file mode 100644 index 000000000..149121b54 --- /dev/null +++ b/lnt/server/api/v5/schemas/orders.py @@ -0,0 +1,136 @@ +"""Order request/response schemas for the v5 API. + +Used by the orders endpoints for OpenAPI documentation and (optionally) +for validation. The dynamic order fields are serialized into a ``fields`` +dict since their names depend on the test suite schema. +""" + +import marshmallow as ma + +from . import BaseSchema +from .common import BaseQuerySchema, CursorPaginationQuerySchema, PaginatedResponseSchema + + +# --------------------------------------------------------------------------- +# Response schemas +# --------------------------------------------------------------------------- + +class OrderSummarySchema(BaseSchema): + """A single order in a list response.""" + fields = ma.fields.Dict( + keys=ma.fields.String(), + values=ma.fields.String(allow_none=True), + metadata={ + 'description': 'Order field values (e.g. llvm_project_revision)', + 'example': {'llvm_project_revision': 'abc123'}, + }, + ) + tag = ma.fields.String( + allow_none=True, + metadata={ + 'description': 'User-assigned label (e.g. release-18.1)', + 'example': 'release-18.1', + }, + ) + + +class OrderNeighborSchema(BaseSchema): + """Reference to a previous or next order.""" + fields = ma.fields.Dict( + keys=ma.fields.String(), + values=ma.fields.String(allow_none=True), + metadata={ + 'description': 'Order field values', + 'example': {'llvm_project_revision': 'abc123'}, + }, + ) + link = ma.fields.String( + allow_none=True, + metadata={'description': 'URL to fetch the referenced order'}, + ) + + +class OrderDetailSchema(BaseSchema): + """Full order detail including previous/next references.""" + fields = ma.fields.Dict( + keys=ma.fields.String(), + values=ma.fields.String(allow_none=True), + metadata={ + 'description': 'Order field values', + 'example': {'llvm_project_revision': 'abc123'}, + }, + ) + tag = ma.fields.String( + allow_none=True, + metadata={ + 'description': 'User-assigned label (e.g. release-18.1)', + 'example': 'release-18.1', + }, + ) + previous_order = ma.fields.Nested( + OrderNeighborSchema, allow_none=True, + metadata={'description': 'Previous order in the total ordering'}, + ) + next_order = ma.fields.Nested( + OrderNeighborSchema, allow_none=True, + metadata={'description': 'Next order in the total ordering'}, + ) + + +# --------------------------------------------------------------------------- +# Request schemas +# --------------------------------------------------------------------------- + +class OrderCreateSchema(BaseSchema): + """Request body for POST /orders. + + The body should contain the order field values as top-level keys + (e.g. ``{"llvm_project_revision": "abc123"}``). + """ + class Meta: + # Allow any keys since order fields are dynamic per test suite + unknown = ma.INCLUDE + + +class OrderUpdateSchema(BaseSchema): + """Request body for PATCH /orders/{order_value}. + + Currently a placeholder -- order metadata updates are limited until + a ``parameters_data`` column is added to the Order model. + """ + class Meta: + unknown = ma.INCLUDE + + +# --------------------------------------------------------------------------- +# Paginated response schemas +# --------------------------------------------------------------------------- + +class PaginatedOrderResponseSchema(PaginatedResponseSchema): + """Paginated list of orders.""" + items = ma.fields.List(ma.fields.Nested(OrderSummarySchema)) + + +# --------------------------------------------------------------------------- +# Query parameter schemas +# --------------------------------------------------------------------------- + +class OrderListQuerySchema(CursorPaginationQuerySchema): + """Query parameters for GET /orders.""" + tag = ma.fields.String( + load_default=None, + metadata={'description': 'Filter by exact tag'}, + ) + tag_prefix = ma.fields.String( + load_default=None, + metadata={'description': 'Filter by tag prefix'}, + ) + + +class OrderDetailQuerySchema(BaseQuerySchema): + """Query parameters for GET /orders/{order_value}. + + Only covers marshmallow-parseable params. Dynamic order field names + for disambiguation continue to be read from request.args directly. + """ + pass diff --git a/lnt/server/api/v5/schemas/profiles.py b/lnt/server/api/v5/schemas/profiles.py new file mode 100644 index 000000000..ef358ffc4 --- /dev/null +++ b/lnt/server/api/v5/schemas/profiles.py @@ -0,0 +1,92 @@ +"""Marshmallow schemas for profile responses in the v5 API.""" + +import marshmallow as ma + +from . import BaseSchema + + +class ProfileMetadataSchema(BaseSchema): + """Schema for profile metadata + top-level counters. + + Returned by GET /runs/{uuid}/tests/{test_name}/profile. + """ + test = ma.fields.String( + required=True, + metadata={'description': 'Name of the test'}, + ) + counters = ma.fields.Dict( + keys=ma.fields.String(), + values=ma.fields.Raw(), + metadata={ + 'description': 'Top-level counters (absolute values)', + 'example': {'cycles': 1500000, 'branch-misses': 2300}, + }, + ) + + +class FunctionInfoSchema(BaseSchema): + """Schema for a single function in the function list.""" + name = ma.fields.String( + required=True, + metadata={'description': 'Function name'}, + ) + counters = ma.fields.Dict( + keys=ma.fields.String(), + values=ma.fields.Raw(), + metadata={ + 'description': 'Counter values as percentages', + 'example': {'cycles': 45.2, 'branch-misses': 12.1}, + }, + ) + length = ma.fields.Integer( + metadata={'description': 'Number of instructions'}, + ) + + +class FunctionListResponseSchema(BaseSchema): + """Schema for GET /runs/{uuid}/tests/{test_name}/profile/functions.""" + functions = ma.fields.List( + ma.fields.Nested(FunctionInfoSchema), + metadata={'description': 'List of functions with counters'}, + ) + + +class InstructionSchema(BaseSchema): + """Schema for a single instruction in the disassembly.""" + address = ma.fields.Raw( + metadata={'description': 'Instruction address'}, + ) + counters = ma.fields.Dict( + keys=ma.fields.String(), + values=ma.fields.Raw(), + metadata={ + 'description': 'Counter values as percentages', + 'example': {'cycles': 0.8, 'branch-misses': 0.1}, + }, + ) + text = ma.fields.String( + metadata={'description': 'Disassembly text'}, + ) + + +class FunctionDetailSchema(BaseSchema): + """Schema for GET /runs/{uuid}/tests/{test_name}/profile/functions/{fn_name}.""" + name = ma.fields.String( + required=True, + metadata={'description': 'Function name'}, + ) + counters = ma.fields.Dict( + keys=ma.fields.String(), + values=ma.fields.Raw(), + metadata={ + 'description': 'Counter values as percentages', + 'example': {'cycles': 45.2, 'branch-misses': 12.1}, + }, + ) + disassembly_format = ma.fields.String( + metadata={'description': 'Disassembly format (raw or marked-up-disassembly)'}, + ) + instructions = ma.fields.List( + ma.fields.Nested(InstructionSchema), + metadata={'description': 'Disassembly with per-instruction counters'}, + ) diff --git a/lnt/server/api/v5/schemas/query.py b/lnt/server/api/v5/schemas/query.py new file mode 100644 index 000000000..64e9354c8 --- /dev/null +++ b/lnt/server/api/v5/schemas/query.py @@ -0,0 +1,101 @@ +"""Marshmallow schemas for the query endpoint in the v5 API.""" + +import marshmallow as ma + +from . import BaseSchema +from .common import BaseQuerySchema, CursorSchema + + +class QueryDataPointSchema(BaseSchema): + """Schema for a single data point in a query response.""" + test = ma.fields.String( + required=True, + metadata={'description': 'Name of the test this data point belongs to'}, + ) + machine = ma.fields.String( + required=True, + metadata={'description': 'Name of the machine this data point belongs to'}, + ) + metric = ma.fields.String( + required=True, + metadata={'description': 'Name of the sample field (metric)'}, + ) + value = ma.fields.Float( + required=True, + metadata={'description': 'The sample value for the field'}, + ) + order = ma.fields.Dict( + keys=ma.fields.String(), + values=ma.fields.String(), + required=True, + metadata={ + 'description': 'Order field values (e.g. llvm_project_revision)', + 'example': {'llvm_project_revision': 'abc123'}, + }, + ) + run_uuid = ma.fields.String( + required=True, + metadata={'description': 'UUID of the run this data point belongs to'}, + ) + timestamp = ma.fields.String( + allow_none=True, + metadata={'description': 'Run start time (ISO 8601)'}, + ) + + +class QueryResponseSchema(BaseSchema): + """Response schema for GET /api/v5/{ts}/query.""" + items = ma.fields.List( + ma.fields.Nested(QueryDataPointSchema), + required=True, + metadata={'description': 'Query data points'}, + ) + cursor = ma.fields.Nested(CursorSchema) + + +# --------------------------------------------------------------------------- +# Query parameter schemas +# --------------------------------------------------------------------------- + +class QueryEndpointQuerySchema(BaseQuerySchema): + """Query parameters for GET /query.""" + machine = ma.fields.String( + load_default=None, + metadata={'description': 'Filter by machine name'}, + ) + test = ma.fields.String( + load_default=None, + metadata={'description': 'Filter by test name'}, + ) + metric = ma.fields.String( + required=True, + metadata={'description': 'Metric name (required)'}, + ) + after_order = ma.fields.String( + load_default=None, + metadata={'description': 'Only return data points after this order value'}, + ) + before_order = ma.fields.String( + load_default=None, + metadata={'description': 'Only return data points before this order value'}, + ) + after_time = ma.fields.String( + load_default=None, + metadata={'description': 'ISO datetime, only data points after this time'}, + ) + before_time = ma.fields.String( + load_default=None, + metadata={'description': 'ISO datetime, only data points before this time'}, + ) + sort = ma.fields.String( + load_default=None, + metadata={'description': 'Comma-separated sort fields: test, order, timestamp (prefix with - for descending)'}, + ) + limit = ma.fields.Integer( + load_default=100, + metadata={'description': 'Maximum number of results per page (default 100, max 10000)'}, + ) + cursor = ma.fields.String( + load_default=None, + metadata={'description': 'Pagination cursor from a previous response'}, + ) diff --git a/lnt/server/api/v5/schemas/regressions.py b/lnt/server/api/v5/schemas/regressions.py new file mode 100644 index 000000000..78c3c8afc --- /dev/null +++ b/lnt/server/api/v5/schemas/regressions.py @@ -0,0 +1,344 @@ +"""Marshmallow schemas for regression, indicator, and field change +request/response in the v5 API. +""" + +import logging +import marshmallow as ma +from webargs import fields as webargs_fields + +logger = logging.getLogger(__name__) + +from . import BaseSchema +from .common import CursorPaginationQuerySchema, PaginatedResponseSchema + + +# --------------------------------------------------------------------------- +# State mapping: API string <-> DB integer +# --------------------------------------------------------------------------- + +STATE_TO_DB = { + 'detected': 0, + 'staged': 1, + 'active': 10, + 'not_to_be_fixed': 20, + 'ignored': 21, + 'fixed': 22, + 'detected_fixed': 23, +} + +DB_TO_STATE = {v: k for k, v in STATE_TO_DB.items()} + +VALID_STATES = sorted(STATE_TO_DB.keys()) + + +def state_to_api(db_value): + """Convert a DB integer state to the API string representation. + + Returns ``'unknown_'`` and logs a warning when the value + does not map to any known state, instead of silently falling back + to ``'detected'`` which would mask data corruption. + """ + try: + return DB_TO_STATE[db_value] + except KeyError: + logger.warning("Unknown regression state in DB: %r", db_value) + return f'unknown_{db_value}' + + +def state_to_db(api_string): + """Convert an API string state to the DB integer representation. + + Returns None if the string is not a valid state. + """ + return STATE_TO_DB.get(api_string) + + +# --------------------------------------------------------------------------- +# Indicator / field change schemas +# --------------------------------------------------------------------------- + +class IndicatorResponseSchema(BaseSchema): + """Schema for a single regression indicator (embedded in regression + detail or in the indicators list endpoint). + """ + field_change_uuid = ma.fields.String( + required=True, + metadata={'description': 'UUID of the field change'}, + ) + test = ma.fields.String( + required=True, + metadata={'description': 'Name of the test'}, + ) + machine = ma.fields.String( + required=True, + metadata={'description': 'Name of the machine'}, + ) + metric = ma.fields.String( + required=True, + metadata={'description': 'Metric name (as defined in the test suite schema)'}, + ) + old_value = ma.fields.Float( + allow_none=True, + metadata={'description': 'Previous value'}, + ) + new_value = ma.fields.Float( + allow_none=True, + metadata={'description': 'New value'}, + ) + start_order = ma.fields.String( + allow_none=True, + metadata={'description': 'Start order field value'}, + ) + end_order = ma.fields.String( + allow_none=True, + metadata={'description': 'End order field value'}, + ) + run_uuid = ma.fields.String( + allow_none=True, + metadata={'description': 'UUID of the run where the change was detected'}, + ) + + +class FieldChangeResponseSchema(BaseSchema): + """Schema for an unassigned field change in the field-changes list.""" + uuid = ma.fields.String( + required=True, + metadata={'description': 'Field change UUID'}, + ) + test = ma.fields.String( + required=True, + metadata={'description': 'Name of the test'}, + ) + machine = ma.fields.String( + required=True, + metadata={'description': 'Name of the machine'}, + ) + metric = ma.fields.String( + required=True, + metadata={'description': 'Metric name (as defined in the test suite schema)'}, + ) + old_value = ma.fields.Float( + allow_none=True, + metadata={'description': 'Previous value'}, + ) + new_value = ma.fields.Float( + allow_none=True, + metadata={'description': 'New value'}, + ) + start_order = ma.fields.String( + allow_none=True, + metadata={'description': 'Start order field value'}, + ) + end_order = ma.fields.String( + allow_none=True, + metadata={'description': 'End order field value'}, + ) + run_uuid = ma.fields.String( + allow_none=True, + metadata={'description': 'UUID of the run where the change was detected'}, + ) + + +class FieldChangeCreateSchema(BaseSchema): + """Schema for POST /field-changes request body.""" + machine = ma.fields.String( + required=True, + metadata={'description': 'Name of the machine'}, + ) + test = ma.fields.String( + required=True, + metadata={'description': 'Name of the test'}, + ) + metric = ma.fields.String( + required=True, + metadata={'description': 'Metric name (as defined in the test suite schema)'}, + ) + old_value = ma.fields.Float( + required=True, + metadata={'description': 'Previous value'}, + ) + new_value = ma.fields.Float( + required=True, + metadata={'description': 'New value'}, + ) + start_order = ma.fields.String( + required=True, + metadata={'description': 'Primary order field value for start'}, + ) + end_order = ma.fields.String( + required=True, + metadata={'description': 'Primary order field value for end'}, + ) + run_uuid = ma.fields.String( + load_default=None, + metadata={'description': 'Optional UUID of the associated run'}, + ) + + +# --------------------------------------------------------------------------- +# Regression request schemas +# --------------------------------------------------------------------------- + +class RegressionCreateSchema(BaseSchema): + """Schema for POST /regressions request body.""" + field_change_uuids = ma.fields.List( + ma.fields.String(), + required=True, + validate=ma.validate.Length(min=1), + metadata={'description': 'List of field change UUIDs to include'}, + ) + title = ma.fields.String( + load_default=None, + metadata={'description': 'Optional title (auto-generated if omitted)'}, + ) + bug = ma.fields.String( + load_default=None, + metadata={'description': 'Optional bug URL'}, + ) + state = ma.fields.String( + load_default=None, + validate=ma.validate.OneOf(VALID_STATES), + metadata={'description': 'Optional initial state (default: detected)', + 'enum': VALID_STATES}, + ) + + +class RegressionUpdateSchema(BaseSchema): + """Schema for PATCH /regressions/{uuid} request body.""" + title = ma.fields.String( + metadata={'description': 'New title'}, + ) + bug = ma.fields.String( + metadata={'description': 'New bug URL'}, + ) + state = ma.fields.String( + validate=ma.validate.OneOf(VALID_STATES), + metadata={'description': 'New state', 'enum': VALID_STATES}, + ) + + +class RegressionMergeSchema(BaseSchema): + """Schema for POST /regressions/{uuid}/merge request body.""" + source_regression_uuids = ma.fields.List( + ma.fields.String(), + required=True, + validate=ma.validate.Length(min=1), + metadata={'description': 'UUIDs of regressions to merge into this one'}, + ) + + +class RegressionSplitSchema(BaseSchema): + """Schema for POST /regressions/{uuid}/split request body.""" + field_change_uuids = ma.fields.List( + ma.fields.String(), + required=True, + validate=ma.validate.Length(min=1), + metadata={'description': 'Field change UUIDs to split into a new regression'}, + ) + + +class IndicatorAddSchema(BaseSchema): + """Schema for POST /regressions/{uuid}/indicators request body.""" + field_change_uuid = ma.fields.String( + required=True, + metadata={'description': 'UUID of the field change to add'}, + ) + + +# --------------------------------------------------------------------------- +# Regression response schemas +# --------------------------------------------------------------------------- + +class RegressionListItemSchema(BaseSchema): + """Schema for a regression in list responses (without embedded + indicators). + """ + uuid = ma.fields.String(required=True) + title = ma.fields.String(allow_none=True) + bug = ma.fields.String(allow_none=True) + state = ma.fields.String( + required=True, + metadata={'description': 'Regression state', 'enum': VALID_STATES}, + ) + + +class RegressionDetailSchema(BaseSchema): + """Schema for a single regression detail response (with embedded + indicators). + """ + uuid = ma.fields.String(required=True) + title = ma.fields.String(allow_none=True) + bug = ma.fields.String(allow_none=True) + state = ma.fields.String( + required=True, + metadata={'description': 'Regression state', 'enum': VALID_STATES}, + ) + indicators = ma.fields.List( + ma.fields.Nested(IndicatorResponseSchema), + metadata={'description': 'Embedded list of regression indicators'}, + ) + + +# --------------------------------------------------------------------------- +# Paginated response schemas +# --------------------------------------------------------------------------- + +class PaginatedRegressionListSchema(PaginatedResponseSchema): + """Paginated list of regressions (without embedded indicators).""" + items = ma.fields.List(ma.fields.Nested(RegressionListItemSchema)) + + +class PaginatedIndicatorResponseSchema(PaginatedResponseSchema): + """Paginated list of regression indicators.""" + items = ma.fields.List(ma.fields.Nested(IndicatorResponseSchema)) + + +class PaginatedFieldChangeResponseSchema(PaginatedResponseSchema): + """Paginated list of unassigned field changes.""" + items = ma.fields.List(ma.fields.Nested(FieldChangeResponseSchema)) + + +# --------------------------------------------------------------------------- +# Query parameter schemas +# --------------------------------------------------------------------------- + +class RegressionListQuerySchema(CursorPaginationQuerySchema): + """Query parameters for GET /regressions.""" + state = webargs_fields.DelimitedList( + ma.fields.String(), + load_default=[], + metadata={'description': 'Filter by state (comma-separated, e.g. active,detected)'}, + ) + machine = ma.fields.String( + load_default=None, + metadata={'description': 'Filter by machine name'}, + ) + test = ma.fields.String( + load_default=None, + metadata={'description': 'Filter by test name'}, + ) + metric = ma.fields.String( + load_default=None, + metadata={'description': 'Filter by metric name'}, + ) + + +class RegressionIndicatorsQuerySchema(CursorPaginationQuerySchema): + """Query parameters for GET /regressions/{uuid}/indicators.""" + pass + + +class FieldChangeListQuerySchema(CursorPaginationQuerySchema): + """Query parameters for GET /field-changes.""" + machine = ma.fields.String( + load_default=None, + metadata={'description': 'Filter by machine name'}, + ) + test = ma.fields.String( + load_default=None, + metadata={'description': 'Filter by test name'}, + ) + metric = ma.fields.String( + load_default=None, + metadata={'description': 'Filter by metric name'}, + ) diff --git a/lnt/server/api/v5/schemas/runs.py b/lnt/server/api/v5/schemas/runs.py new file mode 100644 index 000000000..44f8462ad --- /dev/null +++ b/lnt/server/api/v5/schemas/runs.py @@ -0,0 +1,113 @@ +"""Marshmallow schemas for run request/response in the v5 API.""" + +import marshmallow as ma + +from . import BaseSchema +from .common import BaseQuerySchema, CursorPaginationQuerySchema, PaginatedResponseSchema + + +# --------------------------------------------------------------------------- +# Response schemas +# --------------------------------------------------------------------------- + +class RunResponseSchema(BaseSchema): + """Schema for a single run in responses.""" + uuid = ma.fields.String( + required=True, + metadata={'description': 'Server-generated UUID for the run'}, + ) + machine = ma.fields.String( + required=True, + metadata={'description': 'Name of the machine this run was on'}, + ) + order = ma.fields.Dict( + keys=ma.fields.String(), + values=ma.fields.String(), + metadata={ + 'description': 'Order field values (e.g. revision)', + 'example': {'llvm_project_revision': 'abc123'}, + }, + ) + start_time = ma.fields.String( + allow_none=True, + metadata={'description': 'Run start time (ISO 8601)'}, + ) + end_time = ma.fields.String( + allow_none=True, + metadata={'description': 'Run end time (ISO 8601)'}, + ) + parameters = ma.fields.Dict( + keys=ma.fields.String(), + values=ma.fields.String(), + load_default=None, + metadata={ + 'description': 'Additional run parameters', + 'example': {'run_order': '1', 'optimization_level': '-O2'}, + }, + ) + + +class RunSubmitResponseSchema(BaseSchema): + """Schema for the POST /runs submission response.""" + success = ma.fields.Boolean(required=True) + run_uuid = ma.fields.String( + required=True, + metadata={'description': 'UUID of the newly created run'}, + ) + result_url = ma.fields.String( + metadata={'description': 'URL to fetch the submitted run'}, + ) + + +# --------------------------------------------------------------------------- +# Paginated response schemas +# --------------------------------------------------------------------------- + +class PaginatedRunResponseSchema(PaginatedResponseSchema): + """Paginated list of runs.""" + items = ma.fields.List(ma.fields.Nested(RunResponseSchema)) + + +# --------------------------------------------------------------------------- +# Query parameter schemas +# --------------------------------------------------------------------------- + +class RunListQuerySchema(CursorPaginationQuerySchema): + """Query parameters for GET /runs.""" + machine = ma.fields.String( + load_default=None, + metadata={'description': 'Filter by machine name'}, + ) + order = ma.fields.String( + load_default=None, + metadata={'description': 'Filter by primary order field value'}, + ) + after = ma.fields.String( + load_default=None, + metadata={'description': 'ISO datetime, only runs started after this time'}, + ) + before = ma.fields.String( + load_default=None, + metadata={'description': 'ISO datetime, only runs started before this time'}, + ) + sort = ma.fields.String( + load_default=None, + metadata={'description': 'Sort order. Use -start_time for newest first'}, + ) + + +class RunSubmitQuerySchema(BaseQuerySchema): + """Query parameters for POST /runs.""" + on_machine_conflict = ma.fields.String( + load_default='reject', + validate=ma.validate.OneOf(['reject', 'update']), + metadata={'description': "What to do when machine metadata differs: " + "'reject' aborts, 'update' updates the existing machine"}, + ) + on_existing_run = ma.fields.String( + load_default='reject', + validate=ma.validate.OneOf(['reject', 'replace', 'create']), + metadata={'description': "What to do when a run already exists for " + "this machine+order: 'reject' aborts, 'replace' overwrites " + "the existing run, 'create' creates a new run alongside it"}, + ) diff --git a/lnt/server/api/v5/schemas/samples.py b/lnt/server/api/v5/schemas/samples.py new file mode 100644 index 000000000..6ea0c1665 --- /dev/null +++ b/lnt/server/api/v5/schemas/samples.py @@ -0,0 +1,57 @@ +"""Marshmallow schemas for sample responses in the v5 API.""" + +import marshmallow as ma + +from . import BaseSchema +from .common import CursorPaginationQuerySchema, PaginatedResponseSchema + + +class SampleResponseSchema(BaseSchema): + """Schema for a single sample in API responses. + + Each sample includes the test name, a flag indicating whether it has + a profile, and a ``metrics`` dict containing all non-null sample field + values. + """ + test = ma.fields.String( + required=True, + metadata={'description': 'Name of the test this sample belongs to'}, + ) + has_profile = ma.fields.Boolean( + required=True, + metadata={'description': 'Whether this sample has profile data'}, + ) + metrics = ma.fields.Dict( + keys=ma.fields.String(), + values=ma.fields.Raw(), + metadata={ + 'description': 'Metric field values (metric -> value)', + 'example': {'compile_time': 1.23, 'exec_time': 0.45}, + }, + ) + + +# --------------------------------------------------------------------------- +# Paginated response schemas +# --------------------------------------------------------------------------- + +class PaginatedSampleResponseSchema(PaginatedResponseSchema): + """Paginated list of samples.""" + items = ma.fields.List(ma.fields.Nested(SampleResponseSchema)) + + +class SampleListResponseSchema(BaseSchema): + """Non-paginated list of samples (used for run+test specific queries).""" + items = ma.fields.List(ma.fields.Nested(SampleResponseSchema)) + + +# --------------------------------------------------------------------------- +# Query parameter schemas +# --------------------------------------------------------------------------- + +class RunSamplesQuerySchema(CursorPaginationQuerySchema): + """Query parameters for GET /runs/{uuid}/samples.""" + has_profile = ma.fields.Boolean( + load_default=None, + metadata={'description': 'If true, only return samples with profiles'}, + ) diff --git a/lnt/server/api/v5/schemas/test_suites.py b/lnt/server/api/v5/schemas/test_suites.py new file mode 100644 index 000000000..f905d5945 --- /dev/null +++ b/lnt/server/api/v5/schemas/test_suites.py @@ -0,0 +1,142 @@ +"""Marshmallow schemas for the /api/v5/test-suites endpoints.""" + +import marshmallow as ma + +from . import BaseSchema +from .common import BaseQuerySchema + + +# --------------------------------------------------------------------------- +# Nested field-definition schemas for the POST body +# --------------------------------------------------------------------------- + +class MachineFieldDefSchema(BaseSchema): + name = ma.fields.String( + required=True, + metadata={'description': 'Machine field name'}, + ) + + +class RunFieldDefSchema(BaseSchema): + name = ma.fields.String( + required=True, + metadata={'description': 'Run field name'}, + ) + order = ma.fields.Boolean( + load_default=False, + metadata={'description': 'Whether this field defines the ordering of runs'}, + ) + + +class MetricDefSchema(BaseSchema): + name = ma.fields.String( + required=True, + metadata={'description': 'Metric name'}, + ) + type = ma.fields.String( + load_default='Real', + metadata={'description': 'Data type: Real or Status'}, + ) + bigger_is_better = ma.fields.Boolean( + load_default=False, + metadata={'description': 'Whether larger values indicate better performance'}, + ) + ignore_same_hash = ma.fields.Boolean( + load_default=False, + metadata={'description': 'Skip regression detection when hash is unchanged'}, + ) + display_name = ma.fields.String( + load_default=None, + allow_none=True, + metadata={'description': 'Human-readable display name'}, + ) + unit = ma.fields.String( + load_default=None, + allow_none=True, + metadata={'description': 'Unit of measurement (e.g. "seconds", "bytes")'}, + ) + unit_abbrev = ma.fields.String( + load_default=None, + allow_none=True, + metadata={'description': 'Abbreviated unit (e.g. "s", "B")'}, + ) + + +# --------------------------------------------------------------------------- +# Request schema (POST body) +# --------------------------------------------------------------------------- + +class TestSuiteCreateRequestSchema(BaseSchema): + format_version = ma.fields.String( + required=True, + validate=ma.validate.Equal('2'), + ) + name = ma.fields.String( + required=True, + validate=ma.validate.Regexp( + r'^[A-Za-z][A-Za-z0-9_]*$', + error='Name must start with a letter and contain only ' + 'letters, digits, and underscores.', + ), + ) + machine_fields = ma.fields.List( + ma.fields.Nested(MachineFieldDefSchema), + load_default=[], + ) + run_fields = ma.fields.List( + ma.fields.Nested(RunFieldDefSchema), + load_default=[], + ) + metrics = ma.fields.List( + ma.fields.Nested(MetricDefSchema), + required=True, + ) + + +# --------------------------------------------------------------------------- +# Query parameter schemas +# --------------------------------------------------------------------------- + +class TestSuiteListQuerySchema(BaseQuerySchema): + pass + + +class TestSuiteCreateQuerySchema(BaseQuerySchema): + pass + + +class TestSuiteDetailQuerySchema(BaseQuerySchema): + pass + + +class TestSuiteDeleteQuerySchema(BaseQuerySchema): + confirm = ma.fields.String( + load_default=None, + metadata={'description': 'Must be "true" to confirm deletion'}, + ) + + +# --------------------------------------------------------------------------- +# Response schemas +# --------------------------------------------------------------------------- + +class TestSuiteDetailResponseSchema(BaseSchema): + name = ma.fields.String(required=True) + schema = ma.fields.Dict( + metadata={'description': 'Full test suite schema definition'}, + ) + links = ma.fields.Dict( + keys=ma.fields.String(), + values=ma.fields.String(), + metadata={ + 'description': 'Links to per-suite API resources', + 'example': { + 'machines': '/api/v5/nts/machines', + 'runs': '/api/v5/nts/runs', + }, + }, + ) + + +class TestSuiteListResponseSchema(BaseSchema): + items = ma.fields.List(ma.fields.Nested(TestSuiteDetailResponseSchema)) diff --git a/lnt/server/api/v5/schemas/tests.py b/lnt/server/api/v5/schemas/tests.py new file mode 100644 index 000000000..60c7708b8 --- /dev/null +++ b/lnt/server/api/v5/schemas/tests.py @@ -0,0 +1,43 @@ +"""Marshmallow schemas for test entity request/response in the v5 API.""" + +import marshmallow as ma + +from . import BaseSchema +from .common import CursorPaginationQuerySchema, PaginatedResponseSchema + + +# --------------------------------------------------------------------------- +# Response schemas +# --------------------------------------------------------------------------- + +class TestResponseSchema(BaseSchema): + """Schema for a single test entity in responses.""" + name = ma.fields.String( + required=True, + metadata={'description': 'Test name (may contain slashes)'}, + ) + + +# --------------------------------------------------------------------------- +# Paginated response schemas +# --------------------------------------------------------------------------- + +class PaginatedTestResponseSchema(PaginatedResponseSchema): + """Paginated list of tests.""" + items = ma.fields.List(ma.fields.Nested(TestResponseSchema)) + + +# --------------------------------------------------------------------------- +# Query parameter schemas +# --------------------------------------------------------------------------- + +class TestListQuerySchema(CursorPaginationQuerySchema): + """Query parameters for GET /tests.""" + name_contains = ma.fields.String( + load_default=None, + metadata={'description': 'Filter by substring in test name'}, + ) + name_prefix = ma.fields.String( + load_default=None, + metadata={'description': 'Filter by test name prefix'}, + ) diff --git a/lnt/server/db/fieldchange.py b/lnt/server/db/fieldchange.py index fdf3885e8..cc0800edb 100644 --- a/lnt/server/db/fieldchange.py +++ b/lnt/server/db/fieldchange.py @@ -1,4 +1,5 @@ import difflib +import uuid as uuid_module from sqlalchemy.orm import joinedload from sqlalchemy.orm.session import Session @@ -170,6 +171,7 @@ def regenerate_fieldchanges_for_run(session: Session, ts: TestSuiteDB, run_id: i machine=run.machine, test=test, field_id=field.id) + f.uuid = str(uuid_module.uuid4()) session.add(f) session.flush() try: diff --git a/lnt/server/db/migrations/upgrade_18_to_19.py b/lnt/server/db/migrations/upgrade_18_to_19.py new file mode 100644 index 000000000..325d43831 --- /dev/null +++ b/lnt/server/db/migrations/upgrade_18_to_19.py @@ -0,0 +1,168 @@ +"""This migration adds: + +A) UUID columns (String(36)) to per-testsuite Run, FieldChange, and + Regression tables. Existing rows are backfilled with uuid4 values + in batches. A unique index is created after the backfill. + +B) A global APIKey table for v5 API authentication. +""" + +import uuid + +import sqlalchemy +from sqlalchemy import Column, String, Index, select, text +from lnt.server.db.migrations.util import introspect_table +from lnt.server.db.util import add_column +from lnt.util import logger + +BACKFILL_BATCH_SIZE = 1000 + + +def _add_uuid_column(engine, table_name): + """Add a nullable UUID column to the given table.""" + uuid_col = Column("UUID", String(36)) + try: + add_column(engine, table_name, uuid_col) + except (sqlalchemy.exc.OperationalError, + sqlalchemy.exc.ProgrammingError, + sqlalchemy.exc.IntegrityError) as e: + logger.warning("Skipping UUID column on %s (may already exist): %s", + table_name, e) + + +def _backfill_uuids(engine, table_name): + """Backfill UUID values in batches.""" + table = introspect_table(engine, table_name) + # Find rows without a UUID + with engine.begin() as conn: + count_q = select([sqlalchemy.func.count()]).select_from(table).where( + table.c.UUID.is_(None) + ) + total = conn.execute(count_q).scalar() + + if total == 0: + return + + logger.info("Backfilling %d UUIDs on %s ...", total, table_name) + filled = 0 + while filled < total: + with engine.begin() as conn: + rows = conn.execute( + select([table.c.ID]).where( + table.c.UUID.is_(None) + ).limit(BACKFILL_BATCH_SIZE) + ).fetchall() + if not rows: + break + for row in rows: + conn.execute( + table.update().where( + table.c.ID == row[0] + ).values(UUID=str(uuid.uuid4())) + ) + filled += len(rows) + logger.info("Backfilled %d UUIDs on %s", filled, table_name) + + +def _create_uuid_index(engine, table_name, ts_name): + """Create a unique index on the UUID column.""" + index_name = "ix_{}_uuid".format(table_name.lower()) + table = introspect_table(engine, table_name) + idx = Index(index_name, table.c.UUID, unique=True) + try: + idx.create(engine) + except (sqlalchemy.exc.OperationalError, + sqlalchemy.exc.ProgrammingError, + sqlalchemy.exc.IntegrityError) as e: + logger.warning("Skipping UUID index on %s (may already exist): %s", + table_name, e) + + +def _add_uuid_to_table(engine, table_name, ts_name): + """Add UUID column, backfill, and create unique index.""" + _add_uuid_column(engine, table_name) + _backfill_uuids(engine, table_name) + _create_uuid_index(engine, table_name, ts_name) + + +def _create_apikey_table(engine): + """Create the global APIKey table for v5 API authentication.""" + # Detect dialect for Postgres vs SQLite differences + dialect = engine.dialect.name + + if dialect == 'postgresql': + create_sql = text(""" + CREATE TABLE IF NOT EXISTS "APIKey" ( + "ID" SERIAL PRIMARY KEY, + "Name" VARCHAR(256) NOT NULL, + "KeyPrefix" VARCHAR(8) NOT NULL, + "KeyHash" VARCHAR(64) NOT NULL, + "Scope" VARCHAR(32) NOT NULL, + "CreatedAt" TIMESTAMP NOT NULL, + "LastUsedAt" TIMESTAMP, + "IsActive" BOOLEAN NOT NULL DEFAULT TRUE + ) + """) + else: + create_sql = text(""" + CREATE TABLE IF NOT EXISTS "APIKey" ( + "ID" INTEGER PRIMARY KEY, + "Name" VARCHAR(256) NOT NULL, + "KeyPrefix" VARCHAR(8) NOT NULL, + "KeyHash" VARCHAR(64) NOT NULL, + "Scope" VARCHAR(32) NOT NULL, + "CreatedAt" TIMESTAMP NOT NULL, + "LastUsedAt" TIMESTAMP, + "IsActive" BOOLEAN NOT NULL DEFAULT 1 + ) + """) + + with engine.begin() as conn: + try: + conn.execute(create_sql) + except (sqlalchemy.exc.OperationalError, + sqlalchemy.exc.ProgrammingError, + sqlalchemy.exc.IntegrityError) as e: + logger.warning("Skipping APIKey table creation " + "(may already exist): %s", e) + return # Don't try to create index if table creation failed + + # Create unique index on KeyHash + try: + apikey_table = introspect_table(engine, "APIKey") + idx = Index("ix_apikey_keyhash", apikey_table.c.KeyHash, unique=True) + idx.create(engine) + except (sqlalchemy.exc.OperationalError, + sqlalchemy.exc.ProgrammingError, + sqlalchemy.exc.IntegrityError) as e: + logger.warning("Skipping APIKey KeyHash index " + "(may already exist): %s", e) + + +def upgrade(engine): + """Add UUID columns to per-testsuite tables and create APIKey table.""" + + # Discover test suites dynamically + try: + test_suite = introspect_table(engine, 'TestSuite') + with engine.begin() as conn: + suites = list(conn.execute(select([test_suite]))) + except sqlalchemy.exc.NoSuchTableError: + # TestSuite table may not exist on a brand-new database + suites = [] + + for suite in suites: + # suite columns: ID, Name, DBKeyName, ... + ts_name = suite[2] # DBKeyName + logger.info("Adding UUID columns for test suite: %s", ts_name) + + run_table = "{}_Run".format(ts_name) + fc_table = "{}_FieldChangeV2".format(ts_name) + reg_table = "{}_Regression".format(ts_name) + + _add_uuid_to_table(engine, run_table, ts_name) + _add_uuid_to_table(engine, fc_table, ts_name) + _add_uuid_to_table(engine, reg_table, ts_name) + + # Create the global APIKey table + _create_apikey_table(engine) diff --git a/lnt/server/db/migrations/upgrade_19_to_20.py b/lnt/server/db/migrations/upgrade_19_to_20.py new file mode 100644 index 000000000..14ebad06c --- /dev/null +++ b/lnt/server/db/migrations/upgrade_19_to_20.py @@ -0,0 +1,50 @@ +"""Create TestSuiteRegistryVersion table. + +Single-row table with an integer version counter. Incremented whenever a +test suite is created or deleted so that other workers can detect the change +and reload their in-memory suite caches. +""" + +import sqlalchemy +from sqlalchemy import text +from lnt.util import logger + + +def upgrade(engine): + dialect = engine.dialect.name + + if dialect == 'postgresql': + create_sql = text(""" + CREATE TABLE IF NOT EXISTS "TestSuiteRegistryVersion" ( + "ID" SERIAL PRIMARY KEY, + "Version" INTEGER NOT NULL DEFAULT 0 + ) + """) + else: + create_sql = text(""" + CREATE TABLE IF NOT EXISTS "TestSuiteRegistryVersion" ( + "ID" INTEGER PRIMARY KEY, + "Version" INTEGER NOT NULL DEFAULT 0 + ) + """) + + with engine.begin() as conn: + try: + conn.execute(create_sql) + except (sqlalchemy.exc.OperationalError, + sqlalchemy.exc.ProgrammingError, + sqlalchemy.exc.IntegrityError) as e: + logger.warning("Skipping TestSuiteRegistryVersion table creation " + "(may already exist): %s", e) + return + + # Insert the initial row + with engine.begin() as conn: + count = conn.execute( + text('SELECT COUNT(*) FROM "TestSuiteRegistryVersion"') + ).scalar() + if count == 0: + conn.execute( + text('INSERT INTO "TestSuiteRegistryVersion" ("Version") ' + 'VALUES (0)') + ) diff --git a/lnt/server/db/migrations/upgrade_20_to_21.py b/lnt/server/db/migrations/upgrade_20_to_21.py new file mode 100644 index 000000000..5670a1261 --- /dev/null +++ b/lnt/server/db/migrations/upgrade_20_to_21.py @@ -0,0 +1,49 @@ +"""Add Tag column to per-testsuite Order tables. + +Adds a nullable Tag VARCHAR(64) column with an index to each +{testsuite}_Order table, allowing users to label specific orders +(e.g. "release-18.1") for filtering and comparison. +""" + +import sqlalchemy +from sqlalchemy import Column, String, Index, select +from lnt.server.db.migrations.util import introspect_table +from lnt.server.db.util import add_column +from lnt.util import logger + + +def upgrade(engine): + # Discover test suites dynamically + try: + test_suite = introspect_table(engine, 'TestSuite') + with engine.begin() as conn: + suites = list(conn.execute(select([test_suite]))) + except sqlalchemy.exc.NoSuchTableError: + suites = [] + + for suite in suites: + ts_name = suite[2] # DBKeyName + table_name = "{}_Order".format(ts_name) + logger.info("Adding Tag column to %s", table_name) + + # Add the column + tag_col = Column("Tag", String(64)) + try: + add_column(engine, table_name, tag_col) + except (sqlalchemy.exc.OperationalError, + sqlalchemy.exc.ProgrammingError, + sqlalchemy.exc.IntegrityError) as e: + logger.warning("Skipping Tag column on %s " + "(may already exist): %s", table_name, e) + + # Create index + index_name = "ix_{}_tag".format(table_name.lower()) + try: + table = introspect_table(engine, table_name) + idx = Index(index_name, table.c.Tag) + idx.create(engine) + except (sqlalchemy.exc.OperationalError, + sqlalchemy.exc.ProgrammingError, + sqlalchemy.exc.IntegrityError) as e: + logger.warning("Skipping Tag index on %s " + "(may already exist): %s", table_name, e) diff --git a/lnt/server/db/regression.py b/lnt/server/db/regression.py index 0f55a4da1..422df755d 100644 --- a/lnt/server/db/regression.py +++ b/lnt/server/db/regression.py @@ -1,6 +1,7 @@ from sqlalchemy import desc, asc import re +import uuid as uuid_module from collections import namedtuple from lnt.server.reporting.analysis import RunInfo from lnt.server.ui.util import guess_test_short_name as shortname @@ -45,6 +46,7 @@ def new_regression(session, ts, field_changes): MSG = "Regression of 0 benchmarks" title = MSG regression = ts.Regression(title, "", RegressionState.DETECTED) + regression.uuid = str(uuid_module.uuid4()) session.add(regression) new_ris = [] for fc_id in field_changes: diff --git a/lnt/server/db/testsuite.py b/lnt/server/db/testsuite.py index af88d4109..42d7e551c 100644 --- a/lnt/server/db/testsuite.py +++ b/lnt/server/db/testsuite.py @@ -16,6 +16,16 @@ Base = sqlalchemy.ext.declarative.declarative_base() # type: sqlalchemy.ext.declarative.api.DeclarativeMeta +class TestSuiteRegistryVersion(Base): + """Single-row table tracking how many times suites have been created or + deleted. Workers compare their cached version against this to know when + to reload the in-memory testsuite dict.""" + __tablename__ = 'TestSuiteRegistryVersion' + + id = Column("ID", Integer, primary_key=True) + version = Column("Version", Integer, nullable=False, default=0) + + class SampleType(Base): """ The SampleType table describes an enumeration for the possible types diff --git a/lnt/server/db/testsuitedb.py b/lnt/server/db/testsuitedb.py index 3dc641941..74b4da382 100644 --- a/lnt/server/db/testsuitedb.py +++ b/lnt/server/db/testsuitedb.py @@ -9,6 +9,7 @@ import json import os import itertools +import uuid as uuid_module import aniso8601 import sqlalchemy @@ -226,6 +227,10 @@ class Order(self.base, ParameterizedMixin): uselist=False) order_name_cache = {} + # Optional user-assigned tag for labeling specific orders + # (e.g. "release-18.1"). + tag = Column("Tag", String(64), nullable=True, index=True) + # Dynamically create fields for all of the test suite defined order # fields. class_dict = locals() @@ -354,6 +359,10 @@ class Run(self.base, ParameterizedMixin): end_time = Column("EndTime", DateTime) simple_run_id = Column("SimpleRunID", Integer) + # UUID for v5 API - public stable identifier + uuid = Column("UUID", String(36), unique=True, index=True, + default=lambda: str(uuid_module.uuid4())) + # The parameters blob is used to store any additional information # reported by the run but not promoted into the machine record. # Such data is stored as a JSON encoded blob. @@ -603,6 +612,9 @@ class FieldChange(self.base, ParameterizedMixin): __tablename__ = db_key_name + '_FieldChangeV2' id = Column("ID", Integer, primary_key=True) + # UUID for v5 API - public stable identifier + uuid = Column("UUID", String(36), unique=True, index=True, + default=lambda: str(uuid_module.uuid4())) old_value = Column("OldValue", Float) new_value = Column("NewValue", Float) start_order_id = Column("StartOrderID", Integer, @@ -660,6 +672,9 @@ class Regression(self.base, ParameterizedMixin): __tablename__ = db_key_name + '_Regression' id = Column("ID", Integer, primary_key=True) + # UUID for v5 API - public stable identifier + uuid = Column("UUID", String(36), unique=True, index=True, + default=lambda: str(uuid_module.uuid4())) title = Column("Title", String(256), unique=False, index=False) bug = Column("BugLink", String(256), unique=False, index=False) state = Column("State", Integer) @@ -772,8 +787,14 @@ def __str__(self): sqlalchemy.schema.Index("ix_%s_Sample_RunID_TestID" % db_key_name, Sample.run_id, Sample.test_id) - def create_tables(self, engine): - self.base.metadata.create_all(engine) + def create_tables(self, bind): + """Create per-suite tables. + + *bind* is any SQLAlchemy ``Connectable`` -- typically an ``Engine`` + for standalone use, or a ``Connection`` when the DDL must share a + transaction with pending DML (e.g. flushed metadata inserts). + """ + self.base.metadata.create_all(bind) def get_baselines(self, session): return session.query(self.Baseline).all() @@ -1015,6 +1036,7 @@ def _getOrCreateRun(self, session, run_data, machine, merge): run_parameters.pop('end_time') run = self.Run(new_id, machine, order, start_time, end_time) + run.uuid = str(uuid_module.uuid4()) # First, extract all of the specified run fields. for item in self.run_fields: diff --git a/lnt/server/db/v4db.py b/lnt/server/db/v4db.py index 77311d59c..6f399cd43 100644 --- a/lnt/server/db/v4db.py +++ b/lnt/server/db/v4db.py @@ -78,6 +78,50 @@ def __init__(self, path, config, baseline_revision=0): self.testsuite = dict() self._load_schemas() + # Cache the registry version so we can detect out-of-band changes + # made by other workers (see check_registry_version). + self._registry_version = self._read_registry_version() + + def _read_registry_version(self, session=None): + """Read the current registry version from the DB. + + Returns 0 if the table does not exist yet (pre-migration DB). + """ + close_after = session is None + if close_after: + session = self.make_session() + try: + row = session.query(testsuite.TestSuiteRegistryVersion).first() + return row.version if row is not None else 0 + except (sqlalchemy.exc.OperationalError, + sqlalchemy.exc.ProgrammingError): + return 0 + finally: + if close_after: + session.close() + + def check_registry_version(self, session=None): + """Compare cached version with the DB; reload suites if stale.""" + current = self._read_registry_version(session) + if current != self._registry_version: + self.reload_suites() + self._registry_version = current + + def reload_suites(self): + """Rebuild ``self.testsuite`` from both YAML files and the DB.""" + self.testsuite = dict() + self._load_schemas() + + def increment_registry_version(self, session): + """Bump the registry version so other workers detect the change.""" + try: + row = session.query(testsuite.TestSuiteRegistryVersion).first() + if row is not None: + row.version = row.version + 1 + except (sqlalchemy.exc.OperationalError, + sqlalchemy.exc.ProgrammingError): + pass + def close(self): self.engine.dispose() diff --git a/lnt/server/ui/app.py b/lnt/server/ui/app.py index 82349eb84..1153bbe7b 100644 --- a/lnt/server/ui/app.py +++ b/lnt/server/ui/app.py @@ -181,6 +181,12 @@ def internal_server_error(e): return response return render_template('error.html', message=repr(e)), 500 + # Load the v5 REST API (flask-smorest) AFTER the app-level error + # handlers above so that v5's per-status-code handlers can save + # them as fallbacks for non-v5 routes (see errors.py). + from lnt.server.api.v5 import create_v5_api + app.v5_api = create_v5_api(app) + return app @staticmethod diff --git a/lnt/server/ui/regression_views.py b/lnt/server/ui/regression_views.py index 79df76782..e5d905c1b 100644 --- a/lnt/server/ui/regression_views.py +++ b/lnt/server/ui/regression_views.py @@ -1,5 +1,6 @@ import sqlalchemy import json +import uuid import flask from flask import g from flask import abort @@ -456,6 +457,7 @@ def v4_make_regression(machine_id, test_id, field_index, run_id): machine=run.machine, test=test, field_id=field.id) + f.uuid = str(uuid.uuid4()) session.add(f) # Always update FCs with new values. diff --git a/pyproject.toml b/pyproject.toml index cc6e4aa6f..c816277db 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -42,6 +42,7 @@ dependencies = [ "PyYAML>=6.0.0", "requests", "SQLAlchemy==1.3.24", + "flask-smorest>=0.44.0", "typing", "Werkzeug>=3.1.5", "WTForms>=3.2.0", diff --git a/tests/lit.cfg b/tests/lit.cfg index 29f10a89e..f6949a856 100644 --- a/tests/lit.cfg +++ b/tests/lit.cfg @@ -18,7 +18,7 @@ config.test_format = lit.formats.ShTest() config.suffixes = ['.py', '.shtest'] # excludes: A list of individual files to exclude. -config.excludes = ['__init__.py', 'Inputs', 'utils'] +config.excludes = ['__init__.py', 'Inputs', 'utils', 'v5_test_helpers.py'] # test_source_root: The root path where tests are located. config.test_source_root = os.path.dirname(os.path.abspath(__file__)) diff --git a/tests/server/__init__.py b/tests/server/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/server/api/__init__.py b/tests/server/api/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/server/api/v5/__init__.py b/tests/server/api/v5/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/server/api/v5/test_access_log.py b/tests/server/api/v5/test_access_log.py new file mode 100644 index 000000000..06ef109f8 --- /dev/null +++ b/tests/server/api/v5/test_access_log.py @@ -0,0 +1,182 @@ +# Tests for the v5 access log. +# +# RUN: rm -rf %t.instance %t.pg.log +# RUN: %{utils}/with_postgres.sh %t.pg.log \ +# RUN: %{utils}/with_temporary_instance.py %t.instance \ +# RUN: -- python %s %t.instance +# END. + +import logging +import re +import sys +import os +import unittest +import uuid + +sys.path.insert(0, os.path.dirname(__file__)) +from v5_test_helpers import ( + create_app, create_client, admin_headers, make_scoped_headers, +) + +TS = 'nts' +PREFIX = f'/api/v5/{TS}' + +# Apache combined log format regex. +# Fields: ip - user [timestamp] "method path protocol" status size "referer" "ua" +COMBINED_RE = re.compile( + r'^(?P\S+) - (?P\S+) ' + r'\[(?P[^\]]+)\] ' + r'"(?P\S+) (?P\S+) (?P[^"]+)" ' + r'(?P\d+) (?P\S+) ' + r'"(?P[^"]*)" "(?P[^"]*)"$' +) + + +class _LogCapture(logging.Handler): + """A logging handler that records log lines into a list.""" + + def __init__(self): + super().__init__() + self.lines = [] + + def emit(self, record): + self.lines.append(self.format(record)) + + def clear(self): + self.lines.clear() + + +class _AccessLogTestCase(unittest.TestCase): + """Base class for access log tests. + + Sets up a Flask app, test client, and log capture handler. + Cleans up the handler on teardown to prevent handler accumulation + on the singleton logger. + """ + + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + cls.capture = _LogCapture() + cls.capture.setFormatter(logging.Formatter('%(message)s')) + logger = logging.getLogger('lnt.server.api.v5.access') + logger.addHandler(cls.capture) + + @classmethod + def tearDownClass(cls): + logger = logging.getLogger('lnt.server.api.v5.access') + logger.removeHandler(cls.capture) + super().tearDownClass() + + def setUp(self): + self.capture.clear() + + +class TestAccessLogFormat(_AccessLogTestCase): + """Verify the access log emits valid Apache combined format.""" + + def test_log_line_matches_combined_format(self): + self.client.get(PREFIX + '/orders') + self.assertEqual(len(self.capture.lines), 1) + m = COMBINED_RE.match(self.capture.lines[0]) + self.assertIsNotNone(m, f'Log line does not match combined format: ' + f'{self.capture.lines[0]!r}') + + def test_method_and_path(self): + self.client.get(PREFIX + '/orders') + m = COMBINED_RE.match(self.capture.lines[0]) + self.assertEqual(m.group('method'), 'GET') + self.assertIn('/api/v5/nts/orders', m.group('path')) + + def test_status_code_200(self): + self.client.get(PREFIX + '/orders') + m = COMBINED_RE.match(self.capture.lines[0]) + self.assertEqual(m.group('status'), '200') + + def test_post_status_code_201(self): + rev = f'log-{uuid.uuid4().hex[:8]}' + self.client.post(PREFIX + '/orders', + json={'llvm_project_revision': rev}, + headers=admin_headers()) + m = COMBINED_RE.match(self.capture.lines[0]) + self.assertEqual(m.group('status'), '201') + self.assertEqual(m.group('method'), 'POST') + + +class TestAccessLogUser(_AccessLogTestCase): + """Verify the user field reflects authentication state.""" + + def test_unauthenticated_request(self): + self.client.get(PREFIX + '/orders') + m = COMBINED_RE.match(self.capture.lines[0]) + self.assertEqual(m.group('user'), '-') + + def test_bootstrap_token(self): + self.client.get(PREFIX + '/orders', headers=admin_headers()) + m = COMBINED_RE.match(self.capture.lines[0]) + self.assertEqual(m.group('user'), 'bootstrap') + + def test_named_api_key(self): + headers = make_scoped_headers(self.app, 'read') + self.client.get(PREFIX + '/orders', headers=headers) + m = COMBINED_RE.match(self.capture.lines[0]) + self.assertEqual(m.group('user'), 'test-read') + + +class TestAccessLogMiddleware404(_AccessLogTestCase): + """Verify logging for requests that fail at the middleware level.""" + + def test_nonexistent_testsuite(self): + resp = self.client.get('/api/v5/nonexistent/orders') + self.assertEqual(resp.status_code, 404) + self.assertEqual(len(self.capture.lines), 1) + m = COMBINED_RE.match(self.capture.lines[0]) + self.assertEqual(m.group('status'), '404') + self.assertEqual(m.group('user'), '-') + + +class TestAccessLogHeaders(_AccessLogTestCase): + """Verify Referer and User-Agent appear in the log.""" + + def test_referer_present(self): + self.client.get(PREFIX + '/orders', + headers={'Referer': 'http://example.com/page'}) + m = COMBINED_RE.match(self.capture.lines[0]) + self.assertEqual(m.group('referer'), 'http://example.com/page') + + def test_referer_absent(self): + self.client.get(PREFIX + '/orders') + m = COMBINED_RE.match(self.capture.lines[0]) + self.assertEqual(m.group('referer'), '-') + + def test_user_agent_present(self): + self.client.get(PREFIX + '/orders', + headers={'User-Agent': 'TestBot/1.0'}) + m = COMBINED_RE.match(self.capture.lines[0]) + self.assertEqual(m.group('ua'), 'TestBot/1.0') + + def test_user_agent_absent(self): + # Werkzeug test client sends a default User-Agent; override to empty. + self.client.get(PREFIX + '/orders', + headers={'User-Agent': ''}) + m = COMBINED_RE.match(self.capture.lines[0]) + # Empty string or '-' are both acceptable for absent user agent. + self.assertIn(m.group('ua'), ('', '-')) + + +class TestAccessLogContentLength(_AccessLogTestCase): + """Verify the size field reflects response content length.""" + + def test_response_with_body_has_size(self): + self.client.get(PREFIX + '/orders') + m = COMBINED_RE.match(self.capture.lines[0]) + size = m.group('size') + # Should be a positive integer, not '-' + self.assertNotEqual(size, '-') + self.assertGreater(int(size), 0) + + +if __name__ == '__main__': + unittest.main(argv=[sys.argv[0]]) diff --git a/tests/server/api/v5/test_admin.py b/tests/server/api/v5/test_admin.py new file mode 100644 index 000000000..c566487d0 --- /dev/null +++ b/tests/server/api/v5/test_admin.py @@ -0,0 +1,436 @@ +# Tests for the v5 Admin / API Key endpoints. +# +# RUN: rm -rf %t.instance %t.pg.log +# RUN: %{utils}/with_postgres.sh %t.pg.log \ +# RUN: %{utils}/with_temporary_instance.py %t.instance \ +# RUN: -- python %s %t.instance +# END. + +import sys +import os +import unittest + +sys.path.insert(0, os.path.dirname(__file__)) +from v5_test_helpers import ( + create_app, create_client, admin_headers, make_scoped_headers, +) + + +class TestListAPIKeysEmpty(unittest.TestCase): + """GET /api/v5/admin/api-keys with no keys in the database.""" + + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + cls._admin_headers = admin_headers() + + def test_list_keys_returns_200(self): + resp = self.client.get( + '/api/v5/admin/api-keys', headers=self._admin_headers) + self.assertEqual(resp.status_code, 200) + + def test_list_keys_empty_initially(self): + resp = self.client.get( + '/api/v5/admin/api-keys', headers=self._admin_headers) + data = resp.get_json() + self.assertIn('items', data) + self.assertIsInstance(data['items'], list) + # There may be keys from other tests that ran first; what matters is + # the structure is correct. + + +class TestCreateAPIKey(unittest.TestCase): + """POST /api/v5/admin/api-keys.""" + + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + cls._admin_headers = admin_headers() + + def test_create_key_valid_scope(self): + """Create a key with a valid scope and verify the response.""" + resp = self.client.post( + '/api/v5/admin/api-keys', + json={'name': 'my-read-key', 'scope': 'read'}, + headers=self._admin_headers, + ) + self.assertEqual(resp.status_code, 201) + data = resp.get_json() + self.assertIn('key', data) + self.assertIn('prefix', data) + self.assertIn('scope', data) + self.assertEqual(data['scope'], 'read') + # Prefix is the first 8 chars of the token + self.assertEqual(data['prefix'], data['key'][:8]) + # Token should be reasonably long + self.assertGreaterEqual(len(data['key']), 32) + + def test_create_key_all_valid_scopes(self): + """All five scopes should be accepted.""" + for scope in ('read', 'submit', 'triage', 'manage', 'admin'): + resp = self.client.post( + '/api/v5/admin/api-keys', + json={'name': f'key-{scope}', 'scope': scope}, + headers=self._admin_headers, + ) + self.assertEqual( + resp.status_code, 201, + f"Failed to create key with scope '{scope}': " + f"{resp.get_data(as_text=True)}") + + def test_create_key_invalid_scope(self): + """An invalid scope should return 422.""" + resp = self.client.post( + '/api/v5/admin/api-keys', + json={'name': 'bad-key', 'scope': 'superadmin'}, + headers=self._admin_headers, + ) + self.assertIn(resp.status_code, (400, 422)) + + def test_create_key_missing_name(self): + """Missing 'name' field should return 422.""" + resp = self.client.post( + '/api/v5/admin/api-keys', + json={'scope': 'read'}, + headers=self._admin_headers, + ) + self.assertIn(resp.status_code, (400, 422)) + + def test_create_key_missing_scope(self): + """Missing 'scope' field should return 422.""" + resp = self.client.post( + '/api/v5/admin/api-keys', + json={'name': 'no-scope-key'}, + headers=self._admin_headers, + ) + self.assertIn(resp.status_code, (400, 422)) + + +class TestCreateAPIKeyAuth(unittest.TestCase): + """Auth enforcement on POST /api/v5/admin/api-keys.""" + + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + cls._admin_headers = admin_headers() + + def test_create_key_without_auth(self): + """No auth header should return 401.""" + resp = self.client.post( + '/api/v5/admin/api-keys', + json={'name': 'unauth-key', 'scope': 'read'}, + ) + self.assertEqual(resp.status_code, 401) + + def test_create_key_with_read_scope(self): + """A read-scoped key should get 403 on admin endpoints.""" + read_headers = make_scoped_headers(self.app, 'read') + resp = self.client.post( + '/api/v5/admin/api-keys', + json={'name': 'from-read', 'scope': 'read'}, + headers=read_headers, + ) + self.assertEqual(resp.status_code, 403) + + def test_create_key_with_submit_scope(self): + """A submit-scoped key should get 403 on admin endpoints.""" + submit_headers = make_scoped_headers(self.app, 'submit') + resp = self.client.post( + '/api/v5/admin/api-keys', + json={'name': 'from-submit', 'scope': 'read'}, + headers=submit_headers, + ) + self.assertEqual(resp.status_code, 403) + + def test_create_key_with_triage_scope(self): + """A triage-scoped key should get 403 on admin endpoints.""" + triage_headers = make_scoped_headers(self.app, 'triage') + resp = self.client.post( + '/api/v5/admin/api-keys', + json={'name': 'from-triage', 'scope': 'read'}, + headers=triage_headers, + ) + self.assertEqual(resp.status_code, 403) + + def test_create_key_with_manage_scope(self): + """A manage-scoped key should get 403 on admin endpoints.""" + manage_headers = make_scoped_headers(self.app, 'manage') + resp = self.client.post( + '/api/v5/admin/api-keys', + json={'name': 'from-manage', 'scope': 'read'}, + headers=manage_headers, + ) + self.assertEqual(resp.status_code, 403) + + +class TestListAPIKeysAuth(unittest.TestCase): + """Auth enforcement on GET /api/v5/admin/api-keys.""" + + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_list_keys_without_auth(self): + """No auth header should return 401.""" + resp = self.client.get('/api/v5/admin/api-keys') + self.assertEqual(resp.status_code, 401) + + def test_list_keys_with_read_scope(self): + """A read-scoped key should get 403.""" + read_headers = make_scoped_headers(self.app, 'read') + resp = self.client.get( + '/api/v5/admin/api-keys', headers=read_headers) + self.assertEqual(resp.status_code, 403) + + +class TestListAPIKeysAfterCreate(unittest.TestCase): + """After creating keys, they appear in the list.""" + + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + cls._admin_headers = admin_headers() + + def test_created_key_appears_in_list(self): + # Create a key + create_resp = self.client.post( + '/api/v5/admin/api-keys', + json={'name': 'list-test-key', 'scope': 'submit'}, + headers=self._admin_headers, + ) + self.assertEqual(create_resp.status_code, 201) + created = create_resp.get_json() + prefix = created['prefix'] + + # List keys and check the new key is there + list_resp = self.client.get( + '/api/v5/admin/api-keys', headers=self._admin_headers) + self.assertEqual(list_resp.status_code, 200) + items = list_resp.get_json()['items'] + prefixes = [item['prefix'] for item in items] + self.assertIn(prefix, prefixes) + + # Verify the list item has the correct fields and no hash/raw key + matching = [item for item in items if item['prefix'] == prefix][0] + self.assertEqual(matching['name'], 'list-test-key') + self.assertEqual(matching['scope'], 'submit') + self.assertTrue(matching['is_active']) + self.assertIn('created_at', matching) + # MUST NOT leak the hash or raw key + self.assertNotIn('key_hash', matching) + self.assertNotIn('key', matching) + + +class TestDeleteAPIKey(unittest.TestCase): + """DELETE /api/v5/admin/api-keys/{prefix}.""" + + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + cls._admin_headers = admin_headers() + + def test_delete_key_returns_204(self): + # Create a key first + create_resp = self.client.post( + '/api/v5/admin/api-keys', + json={'name': 'delete-me', 'scope': 'read'}, + headers=self._admin_headers, + ) + self.assertEqual(create_resp.status_code, 201) + prefix = create_resp.get_json()['prefix'] + + # Delete it + delete_resp = self.client.delete( + f'/api/v5/admin/api-keys/{prefix}', + headers=self._admin_headers, + ) + self.assertEqual(delete_resp.status_code, 204) + + def test_delete_nonexistent_prefix(self): + """Deleting a prefix that does not exist should return 404.""" + resp = self.client.delete( + '/api/v5/admin/api-keys/zzzzzzzz', + headers=self._admin_headers, + ) + self.assertEqual(resp.status_code, 404) + + def test_deleted_key_is_soft_deleted(self): + """After deletion the key is inactive but still appears in the list.""" + # Create + create_resp = self.client.post( + '/api/v5/admin/api-keys', + json={'name': 'soft-del', 'scope': 'read'}, + headers=self._admin_headers, + ) + prefix = create_resp.get_json()['prefix'] + + # Delete + self.client.delete( + f'/api/v5/admin/api-keys/{prefix}', + headers=self._admin_headers, + ) + + # The key should still show in the list but with is_active=False + list_resp = self.client.get( + '/api/v5/admin/api-keys', headers=self._admin_headers) + items = list_resp.get_json()['items'] + matching = [i for i in items if i['prefix'] == prefix] + self.assertEqual(len(matching), 1) + self.assertFalse(matching[0]['is_active']) + + +class TestDeleteAPIKeyAuth(unittest.TestCase): + """Auth enforcement on DELETE /api/v5/admin/api-keys/{prefix}.""" + + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_delete_key_without_auth(self): + resp = self.client.delete('/api/v5/admin/api-keys/abcd1234') + self.assertEqual(resp.status_code, 401) + + def test_delete_key_with_read_scope(self): + read_headers = make_scoped_headers(self.app, 'read') + resp = self.client.delete( + '/api/v5/admin/api-keys/abcd1234', headers=read_headers) + self.assertEqual(resp.status_code, 403) + + +class TestCreatedKeyWorksForAuth(unittest.TestCase): + """Keys created via the admin endpoint actually authenticate requests.""" + + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + cls._admin_headers = admin_headers() + + def test_created_read_key_can_access_discovery(self): + """A newly created read key should work on a GET endpoint.""" + # Create a read-scoped key + create_resp = self.client.post( + '/api/v5/admin/api-keys', + json={'name': 'auth-test-read', 'scope': 'read'}, + headers=self._admin_headers, + ) + self.assertEqual(create_resp.status_code, 201) + raw_token = create_resp.get_json()['key'] + + # Use the raw token to access the discovery endpoint + headers = {'Authorization': f'Bearer {raw_token}'} + resp = self.client.get('/api/v5/', headers=headers) + self.assertEqual(resp.status_code, 200) + + def test_created_read_key_can_access_fields(self): + """A newly created read key should access /nts/machines.""" + create_resp = self.client.post( + '/api/v5/admin/api-keys', + json={'name': 'auth-test-fields', 'scope': 'read'}, + headers=self._admin_headers, + ) + raw_token = create_resp.get_json()['key'] + + headers = {'Authorization': f'Bearer {raw_token}'} + resp = self.client.get('/api/v5/nts/machines', headers=headers) + self.assertEqual(resp.status_code, 200) + + def test_revoked_key_is_rejected(self): + """After revoking a key, it should no longer authenticate.""" + # Create a key + create_resp = self.client.post( + '/api/v5/admin/api-keys', + json={'name': 'revoke-test', 'scope': 'admin'}, + headers=self._admin_headers, + ) + created = create_resp.get_json() + raw_token = created['key'] + prefix = created['prefix'] + + # Verify it works + headers = {'Authorization': f'Bearer {raw_token}'} + resp = self.client.get( + '/api/v5/admin/api-keys', headers=headers) + self.assertEqual(resp.status_code, 200) + + # Revoke it + self.client.delete( + f'/api/v5/admin/api-keys/{prefix}', + headers=self._admin_headers, + ) + + # Now it should be rejected -- admin endpoints require admin scope, + # so a revoked key with no valid auth should get 401 + resp2 = self.client.get( + '/api/v5/admin/api-keys', headers=headers) + self.assertEqual(resp2.status_code, 401) + + def test_created_read_key_cannot_access_admin(self): + """A read-scoped key should be forbidden from admin endpoints.""" + create_resp = self.client.post( + '/api/v5/admin/api-keys', + json={'name': 'read-no-admin', 'scope': 'read'}, + headers=self._admin_headers, + ) + raw_token = create_resp.get_json()['key'] + + headers = {'Authorization': f'Bearer {raw_token}'} + resp = self.client.get( + '/api/v5/admin/api-keys', headers=headers) + self.assertEqual(resp.status_code, 403) + + def test_created_admin_key_can_create_more_keys(self): + """An admin-scoped key should be able to create other keys.""" + # Create an admin key + create_resp = self.client.post( + '/api/v5/admin/api-keys', + json={'name': 'admin-creator', 'scope': 'admin'}, + headers=self._admin_headers, + ) + raw_token = create_resp.get_json()['key'] + new_admin_headers = {'Authorization': f'Bearer {raw_token}'} + + # Use it to create another key + resp = self.client.post( + '/api/v5/admin/api-keys', + json={'name': 'child-key', 'scope': 'read'}, + headers=new_admin_headers, + ) + self.assertEqual(resp.status_code, 201) + + +class TestAdminUnknownParams(unittest.TestCase): + """Test that unknown query parameters are rejected with 400.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + cls._admin_headers = admin_headers() + + def test_api_keys_list_unknown_param_returns_400(self): + resp = self.client.get( + '/api/v5/admin/api-keys?bogus=1', + headers=self._admin_headers) + self.assertEqual(resp.status_code, 400) + data = resp.get_json() + self.assertIn('bogus', data['error']['message']) + + +if __name__ == '__main__': + unittest.main(argv=[sys.argv[0]], exit=True) diff --git a/tests/server/api/v5/test_auth.py b/tests/server/api/v5/test_auth.py new file mode 100644 index 000000000..08f3219c8 --- /dev/null +++ b/tests/server/api/v5/test_auth.py @@ -0,0 +1,222 @@ +# Tests for the v5 API authentication system. +# +# RUN: rm -rf %t.instance %t.pg.log +# RUN: %{utils}/with_postgres.sh %t.pg.log \ +# RUN: %{utils}/with_temporary_instance.py %t.instance \ +# RUN: -- python %s %t.instance +# END. + +import sys +import os +import unittest + +sys.path.insert(0, os.path.dirname(__file__)) +from v5_test_helpers import ( + create_app, create_client, admin_headers, make_scoped_headers, +) + +from lnt.server.api.v5.auth import ( + SCOPE_LEVELS, _get_scope_level, _hash_token, +) + + +class TestScopeHierarchy(unittest.TestCase): + def test_scope_levels_ordering(self): + self.assertLess(SCOPE_LEVELS['read'], SCOPE_LEVELS['submit']) + self.assertLess(SCOPE_LEVELS['submit'], SCOPE_LEVELS['triage']) + self.assertLess(SCOPE_LEVELS['triage'], SCOPE_LEVELS['manage']) + self.assertLess(SCOPE_LEVELS['manage'], SCOPE_LEVELS['admin']) + + def test_get_scope_level_valid(self): + self.assertEqual(_get_scope_level('read'), 0) + self.assertEqual(_get_scope_level('admin'), 4) + + def test_get_scope_level_invalid(self): + self.assertEqual(_get_scope_level('nonexistent'), -1) + + def test_all_scopes_present(self): + expected = {'read', 'submit', 'triage', 'manage', 'admin'} + self.assertEqual(set(SCOPE_LEVELS.keys()), expected) + + +class TestTokenHashing(unittest.TestCase): + def test_hash_deterministic(self): + token = 'test_token_abc123' + self.assertEqual(_hash_token(token), _hash_token(token)) + + def test_hash_different_for_different_tokens(self): + self.assertNotEqual(_hash_token('token_a'), _hash_token('token_b')) + + def test_hash_is_hex_string(self): + h = _hash_token('some_token') + self.assertEqual(len(h), 64) # SHA-256 hex + int(h, 16) # Should not raise + + +class TestBootstrapToken(unittest.TestCase): + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + cls._admin_headers = admin_headers() + + def test_bootstrap_token_allows_read(self): + resp = self.client.get('/api/v5/', headers=self._admin_headers) + self.assertEqual(resp.status_code, 200) + + def test_bootstrap_token_allows_admin_paths(self): + """Admin token should not get 401 or 403 on discovery.""" + resp = self.client.get('/api/v5/', headers=self._admin_headers) + self.assertEqual(resp.status_code, 200) + + def test_bootstrap_token_grants_admin_scope(self): + """Bootstrap token should resolve to admin scope via constant-time + comparison (hmac.compare_digest).""" + with self.app.test_request_context( + headers=self._admin_headers): + from lnt.server.api.v5.auth import _resolve_bearer_token + scope, api_key = _resolve_bearer_token() + self.assertEqual(scope, 'admin') + self.assertIsNone(api_key) + + def test_wrong_bootstrap_token_returns_401(self): + """A token that does not match the bootstrap token (and has no + matching DB key) should abort with 401 on a read-scoped endpoint.""" + wrong_headers = {'Authorization': 'Bearer wrong_token_value'} + resp = self.client.get('/api/v5/nts/machines', headers=wrong_headers) + self.assertEqual(resp.status_code, 401) + + +class TestUnauthenticatedAccess(unittest.TestCase): + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_discovery_no_auth(self): + resp = self.client.get('/api/v5/') + self.assertEqual(resp.status_code, 200) + + def test_fields_no_auth(self): + resp = self.client.get('/api/v5/nts/machines') + self.assertEqual(resp.status_code, 200) + + def test_schema_no_auth(self): + resp = self.client.get('/api/v5/test-suites/nts') + self.assertEqual(resp.status_code, 200) + + +class TestInvalidToken(unittest.TestCase): + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_invalid_bearer_token_on_read_endpoint_returns_401(self): + """An invalid Bearer token must return 401, not silently succeed.""" + headers = {'Authorization': 'Bearer totally_invalid_token_xyz'} + resp = self.client.get('/api/v5/nts/machines', headers=headers) + self.assertEqual(resp.status_code, 401) + + def test_invalid_bearer_token_on_testsuite_read_returns_401(self): + """An invalid Bearer token on a testsuite read endpoint returns 401.""" + headers = {'Authorization': 'Bearer bogus_token_abc123'} + resp = self.client.get('/api/v5/nts/tests', headers=headers) + self.assertEqual(resp.status_code, 401) + + def test_empty_bearer_token_returns_401(self): + """'Bearer ' with no actual token value returns 401.""" + headers = {'Authorization': 'Bearer '} + resp = self.client.get('/api/v5/nts/machines', headers=headers) + self.assertEqual(resp.status_code, 401) + + def test_invalid_token_on_unprotected_discovery_passes(self): + """Discovery endpoint has no auth decorator, so invalid tokens + do not cause 401 there — it is truly public.""" + headers = {'Authorization': 'Bearer totally_invalid_token_xyz'} + resp = self.client.get('/api/v5/', headers=headers) + self.assertEqual(resp.status_code, 200) + + def test_malformed_auth_header_allows_unauthenticated_read(self): + """Non-Bearer Authorization header is treated as no-auth (not 401), + preserving backward compatibility with proxies/middleware that may + inject other schemes.""" + headers = {'Authorization': 'NotBearer sometoken'} + resp = self.client.get('/api/v5/nts/machines', headers=headers) + self.assertEqual(resp.status_code, 200) + + +class TestScopedAPIKeys(unittest.TestCase): + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + cls._read_headers = make_scoped_headers(cls.app, 'read') + + def test_read_key_can_access_discovery(self): + resp = self.client.get('/api/v5/', headers=self._read_headers) + self.assertEqual(resp.status_code, 200) + + def test_read_key_can_access_fields(self): + resp = self.client.get( + '/api/v5/nts/machines', headers=self._read_headers) + self.assertEqual(resp.status_code, 200) + + +class TestRequireAuthForReads(unittest.TestCase): + """Tests for the require_auth_for_reads config flag. + + When require_auth_for_reads is True, unauthenticated GET requests to + read-scoped endpoints must return 401, while authenticated requests + succeed. + """ + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + # Enable require_auth_for_reads on this app instance + cls.app.old_config.require_auth_for_reads = True + cls.client = create_client(cls.app) + cls._read_headers = make_scoped_headers(cls.app, 'read') + + @classmethod + def tearDownClass(cls): + # Restore default to avoid affecting other tests + cls.app.old_config.require_auth_for_reads = False + super().tearDownClass() + + def test_unauthenticated_read_returns_401(self): + """Unauthenticated GET to a read-scoped endpoint returns 401.""" + resp = self.client.get('/api/v5/nts/machines') + self.assertEqual(resp.status_code, 401) + + def test_unauthenticated_fields_returns_401(self): + """Unauthenticated GET to /tests returns 401.""" + resp = self.client.get('/api/v5/nts/tests') + self.assertEqual(resp.status_code, 401) + + def test_authenticated_read_returns_200(self): + """Authenticated GET with read scope returns 200.""" + resp = self.client.get( + '/api/v5/nts/machines', headers=self._read_headers) + self.assertEqual(resp.status_code, 200) + + def test_authenticated_fields_returns_200(self): + """Authenticated GET to /tests with read scope returns 200.""" + resp = self.client.get( + '/api/v5/nts/tests', headers=self._read_headers) + self.assertEqual(resp.status_code, 200) + + def test_admin_token_still_works(self): + """Admin bootstrap token still works when reads require auth.""" + resp = self.client.get( + '/api/v5/nts/machines', headers=admin_headers()) + self.assertEqual(resp.status_code, 200) + + +if __name__ == '__main__': + unittest.main(argv=[sys.argv[0]], exit=True) diff --git a/tests/server/api/v5/test_discovery.py b/tests/server/api/v5/test_discovery.py new file mode 100644 index 000000000..dd319733d --- /dev/null +++ b/tests/server/api/v5/test_discovery.py @@ -0,0 +1,114 @@ +# Tests for the v5 discovery endpoint (GET /api/v5/). +# +# RUN: rm -rf %t.instance %t.pg.log +# RUN: %{utils}/with_postgres.sh %t.pg.log \ +# RUN: %{utils}/with_temporary_instance.py %t.instance \ +# RUN: -- python %s %t.instance +# END. + +import sys +import os +import unittest + +sys.path.insert(0, os.path.dirname(__file__)) +from v5_test_helpers import create_app, create_client + + +class TestDiscovery(unittest.TestCase): + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_discovery_returns_200(self): + resp = self.client.get('/api/v5/') + self.assertEqual(resp.status_code, 200) + + def test_discovery_contains_test_suites(self): + resp = self.client.get('/api/v5/') + data = resp.get_json() + self.assertIn('test_suites', data) + self.assertIsInstance(data['test_suites'], list) + self.assertGreater(len(data['test_suites']), 0) + + def test_discovery_suite_has_name_and_links(self): + resp = self.client.get('/api/v5/') + data = resp.get_json() + suite = data['test_suites'][0] + self.assertIn('name', suite) + self.assertIn('links', suite) + + def test_discovery_suite_links_are_complete(self): + resp = self.client.get('/api/v5/') + data = resp.get_json() + suite = data['test_suites'][0] + links = suite['links'] + expected_keys = { + 'machines', 'orders', 'runs', 'tests', + 'regressions', 'field_changes', 'query' + } + self.assertEqual(set(links.keys()), expected_keys) + + def test_discovery_links_contain_suite_name(self): + resp = self.client.get('/api/v5/') + data = resp.get_json() + for suite in data['test_suites']: + name = suite['name'] + for key, url in suite['links'].items(): + self.assertIn( + name, url, + f"Link {key}={url} does not contain suite name {name}") + + def test_discovery_no_auth_required(self): + """Discovery should work without any auth headers.""" + resp = self.client.get('/api/v5/') + self.assertEqual(resp.status_code, 200) + + def test_discovery_has_nts_suite(self): + """The 'nts' test suite should be present.""" + resp = self.client.get('/api/v5/') + data = resp.get_json() + names = [s['name'] for s in data['test_suites']] + self.assertIn('nts', names) + + def test_discovery_cors_headers(self): + """CORS headers should be present on v5 responses.""" + resp = self.client.get('/api/v5/') + self.assertEqual(resp.headers.get('Access-Control-Allow-Origin'), '*') + + def test_discovery_includes_doc_links(self): + """Discovery should include links to OpenAPI spec and Swagger UI.""" + resp = self.client.get('/api/v5/') + data = resp.get_json() + self.assertIn('links', data) + self.assertIn('openapi', data['links']) + self.assertIn('swagger_ui', data['links']) + self.assertIn('test_suites', data['links']) + + def test_swagger_ui_returns_200(self): + resp = self.client.get('/api/v5/openapi/swagger-ui') + self.assertEqual(resp.status_code, 200) + + def test_openapi_json_returns_200(self): + resp = self.client.get('/api/v5/openapi/openapi.json') + self.assertEqual(resp.status_code, 200) + + +class TestDiscoveryUnknownParams(unittest.TestCase): + """Test that unknown query parameters are rejected with 400.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_discovery_unknown_param_returns_400(self): + resp = self.client.get('/api/v5/?bogus=1') + self.assertEqual(resp.status_code, 400) + data = resp.get_json() + self.assertIn('bogus', data['error']['message']) + + +if __name__ == '__main__': + unittest.main(argv=[sys.argv[0]], exit=True) diff --git a/tests/server/api/v5/test_errors.py b/tests/server/api/v5/test_errors.py new file mode 100644 index 000000000..427b7e829 --- /dev/null +++ b/tests/server/api/v5/test_errors.py @@ -0,0 +1,190 @@ +# Tests for the v5 API error format. +# +# RUN: rm -rf %t.instance %t.pg.log +# RUN: %{utils}/with_postgres.sh %t.pg.log \ +# RUN: %{utils}/with_temporary_instance.py %t.instance \ +# RUN: -- python %s %t.instance +# END. + +import sys +import os +import unittest + +sys.path.insert(0, os.path.dirname(__file__)) +from v5_test_helpers import create_app, create_client, admin_headers + + +TS = 'nts' +PREFIX = f'/api/v5/{TS}' + + +class TestErrors(unittest.TestCase): + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_404_has_error_key(self): + resp = self.client.get('/api/v5/nonexistent_suite/machines') + self.assertEqual(resp.status_code, 404) + data = resp.get_json() + self.assertIn('error', data) + self.assertIn('code', data['error']) + self.assertIn('message', data['error']) + + def test_404_error_code(self): + resp = self.client.get('/api/v5/nonexistent_suite/machines') + data = resp.get_json() + self.assertEqual(data['error']['code'], 'not_found') + + def test_405_method_not_allowed(self): + """POST to a GET-only endpoint should return 405.""" + resp = self.client.post('/api/v5/') + self.assertEqual(resp.status_code, 405) + data = resp.get_json() + self.assertIn('error', data) + self.assertEqual(data['error']['code'], 'method_not_allowed') + + def test_v5_errors_are_json(self): + """Error responses should always be JSON.""" + resp = self.client.get('/api/v5/nonexistent_suite/machines') + self.assertTrue(resp.content_type.startswith('application/json')) + + def test_v5_error_cors_headers(self): + """Error responses should also have CORS headers.""" + resp = self.client.get('/api/v5/nonexistent_suite/machines') + self.assertEqual( + resp.headers.get('Access-Control-Allow-Origin'), '*') + + +class TestV5ApiError(unittest.TestCase): + """Test the V5ApiError exception class directly.""" + + def test_v5_api_error_attributes(self): + """V5ApiError stores status_code, error_code, and message.""" + from lnt.server.api.v5.errors import V5ApiError + exc = V5ApiError(404, 'not_found', 'Machine not found') + self.assertEqual(exc.status_code, 404) + self.assertEqual(exc.error_code, 'not_found') + self.assertEqual(exc.message, 'Machine not found') + self.assertEqual(str(exc), 'Machine not found') + + def test_v5_api_error_is_exception(self): + """V5ApiError inherits from Exception.""" + from lnt.server.api.v5.errors import V5ApiError + exc = V5ApiError(400, 'validation_error', 'Bad input') + self.assertIsInstance(exc, Exception) + + def test_abort_with_error_raises_v5_api_error(self): + """abort_with_error raises V5ApiError, not flask.abort.""" + from lnt.server.api.v5.errors import V5ApiError, abort_with_error + with self.assertRaises(V5ApiError) as ctx: + abort_with_error(400, 'test message') + self.assertEqual(ctx.exception.status_code, 400) + self.assertEqual(ctx.exception.error_code, 'validation_error') + self.assertEqual(ctx.exception.message, 'test message') + + def test_abort_with_error_unknown_status(self): + """abort_with_error maps unknown status codes to 'error'.""" + from lnt.server.api.v5.errors import V5ApiError, abort_with_error + with self.assertRaises(V5ApiError) as ctx: + abort_with_error(418, "I'm a teapot") + self.assertEqual(ctx.exception.status_code, 418) + self.assertEqual(ctx.exception.error_code, 'error') + + +class TestAbortWithErrorIntegration(unittest.TestCase): + """Test that abort_with_error produces correct HTTP responses end-to-end. + + These tests trigger abort_with_error through real endpoint calls to + verify the V5ApiError handler returns the expected JSON format and + status code. + """ + + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + cls.headers = admin_headers() + + def test_400_from_abort_with_error(self): + """POST with invalid body triggers abort_with_error(400, ...).""" + resp = self.client.post( + PREFIX + '/machines', + data='not json', + content_type='application/json', + headers=self.headers, + ) + self.assertEqual(resp.status_code, 400) + data = resp.get_json() + self.assertIn('error', data) + self.assertEqual(data['error']['code'], 'validation_error') + self.assertIsInstance(data['error']['message'], str) + self.assertTrue(resp.content_type.startswith('application/json')) + + def test_404_from_abort_with_error(self): + """GET a non-existent machine triggers abort_with_error(404, ...).""" + resp = self.client.get( + PREFIX + '/machines/does_not_exist', + headers=self.headers, + ) + self.assertEqual(resp.status_code, 404) + data = resp.get_json() + self.assertIn('error', data) + self.assertEqual(data['error']['code'], 'not_found') + self.assertIn('does_not_exist', data['error']['message']) + self.assertTrue(resp.content_type.startswith('application/json')) + + def test_404_run_not_found(self): + """GET a non-existent run UUID triggers abort_with_error(404, ...).""" + fake_uuid = '00000000-0000-0000-0000-000000000000' + resp = self.client.get( + PREFIX + '/runs/' + fake_uuid, + headers=self.headers, + ) + self.assertEqual(resp.status_code, 404) + data = resp.get_json() + self.assertIn('error', data) + self.assertEqual(data['error']['code'], 'not_found') + self.assertTrue(resp.content_type.startswith('application/json')) + + def test_409_duplicate_machine(self): + """Creating a duplicate machine triggers abort_with_error(409, ...).""" + import json + import uuid as _uuid + unique_name = 'error-test-machine-' + _uuid.uuid4().hex[:8] + # Create the machine first + resp = self.client.post( + PREFIX + '/machines', + data=json.dumps({'name': unique_name}), + content_type='application/json', + headers=self.headers, + ) + self.assertEqual(resp.status_code, 201) + # Try to create it again + resp = self.client.post( + PREFIX + '/machines', + data=json.dumps({'name': unique_name}), + content_type='application/json', + headers=self.headers, + ) + self.assertEqual(resp.status_code, 409) + data = resp.get_json() + self.assertIn('error', data) + self.assertEqual(data['error']['code'], 'conflict') + self.assertIn(unique_name, data['error']['message']) + + def test_error_response_has_exactly_two_keys(self): + """Error envelope should contain exactly 'code' and 'message'.""" + resp = self.client.get( + PREFIX + '/machines/does_not_exist', + headers=self.headers, + ) + data = resp.get_json() + self.assertEqual(set(data['error'].keys()), {'code', 'message'}) + + +if __name__ == '__main__': + unittest.main(argv=[sys.argv[0]], exit=True) diff --git a/tests/server/api/v5/test_etag.py b/tests/server/api/v5/test_etag.py new file mode 100644 index 000000000..ed14011d6 --- /dev/null +++ b/tests/server/api/v5/test_etag.py @@ -0,0 +1,69 @@ +# Tests for the v5 API ETag utilities. +# +# RUN: rm -rf %t.instance %t.pg.log +# RUN: %{utils}/with_postgres.sh %t.pg.log \ +# RUN: %{utils}/with_temporary_instance.py %t.instance \ +# RUN: -- python %s %t.instance +# END. + +import sys +import os +import unittest + +sys.path.insert(0, os.path.dirname(__file__)) +from v5_test_helpers import create_app, create_client + +from lnt.server.api.v5.etag import compute_etag + + +class TestComputeETag(unittest.TestCase): + def test_deterministic(self): + data = {'key': 'value', 'number': 42} + self.assertEqual(compute_etag(data), compute_etag(data)) + + def test_weak_etag_format(self): + etag = compute_etag({'a': 1}) + self.assertTrue(etag.startswith('W/"')) + self.assertTrue(etag.endswith('"')) + + def test_different_data_different_etag(self): + e1 = compute_etag({'a': 1}) + e2 = compute_etag({'a': 2}) + self.assertNotEqual(e1, e2) + + def test_order_independent(self): + """Sort keys ensures order independence.""" + e1 = compute_etag({'a': 1, 'b': 2}) + e2 = compute_etag({'b': 2, 'a': 1}) + self.assertEqual(e1, e2) + + def test_empty_dict(self): + etag = compute_etag({}) + self.assertTrue(etag.startswith('W/"')) + + def test_empty_list(self): + etag = compute_etag([]) + self.assertTrue(etag.startswith('W/"')) + + +class TestETagOnEndpoints(unittest.TestCase): + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_machines_endpoint_returns_200(self): + """A GET to /machines should succeed (ETags are applied to detail + endpoints, not lists).""" + resp = self.client.get('/api/v5/nts/machines') + self.assertEqual(resp.status_code, 200) + + def test_test_suite_detail_returns_200(self): + """Test suite detail endpoint returns metadata.""" + resp = self.client.get('/api/v5/test-suites/nts') + self.assertEqual(resp.status_code, 200) + + +if __name__ == '__main__': + unittest.main(argv=[sys.argv[0]], exit=True) diff --git a/tests/server/api/v5/test_field_changes.py b/tests/server/api/v5/test_field_changes.py new file mode 100644 index 000000000..9c6240df2 --- /dev/null +++ b/tests/server/api/v5/test_field_changes.py @@ -0,0 +1,857 @@ +# Tests for the v5 field change triage endpoints. +# +# RUN: rm -rf %t.instance %t.pg.log +# RUN: %{utils}/with_postgres.sh %t.pg.log \ +# RUN: %{utils}/with_temporary_instance.py %t.instance \ +# RUN: -- python %s %t.instance +# END. + +import json +import sys +import os +import unittest +import uuid + +sys.path.insert(0, os.path.dirname(__file__)) +from v5_test_helpers import ( + create_app, create_client, make_scoped_headers, admin_headers, + create_machine, create_order, create_run, create_test, + create_fieldchange, create_regression, collect_all_pages, +) + + +def _submit_headers(app): + return make_scoped_headers(app, 'submit') + + +TS = 'nts' +PREFIX = f'/api/v5/{TS}' + + +def _triage_headers(app): + return make_scoped_headers(app, 'triage') + + +def _create_unassigned_fieldchange(app): + """Create a field change that is not assigned to any regression and not + ignored. Returns the field change UUID. + """ + db = app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + machine = create_machine( + session, ts, name=f'fc-m-{uuid.uuid4().hex[:8]}') + order1 = create_order( + session, ts, revision=f'fc-o1-{uuid.uuid4().hex[:8]}') + order2 = create_order( + session, ts, revision=f'fc-o2-{uuid.uuid4().hex[:8]}') + test = create_test( + session, ts, name=f'fc/test/{uuid.uuid4().hex[:8]}') + run = create_run(session, ts, machine, order2) + field = ts.sample_fields[0] + fc = create_fieldchange(session, ts, order1, order2, machine, test, + field, old_value=10.0, new_value=20.0, run=run) + fc_uuid = fc.uuid + session.commit() + session.close() + return fc_uuid + + +def _create_assigned_fieldchange(app): + """Create a field change that IS assigned to a regression (has a + RegressionIndicator). Returns the field change UUID. + """ + db = app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + machine = create_machine( + session, ts, name=f'fc-assigned-{uuid.uuid4().hex[:8]}') + order1 = create_order( + session, ts, revision=f'fc-a-o1-{uuid.uuid4().hex[:8]}') + order2 = create_order( + session, ts, revision=f'fc-a-o2-{uuid.uuid4().hex[:8]}') + test = create_test( + session, ts, name=f'fc/assigned/{uuid.uuid4().hex[:8]}') + run = create_run(session, ts, machine, order2) + field = ts.sample_fields[0] + fc = create_fieldchange(session, ts, order1, order2, machine, test, + field, old_value=1.0, new_value=2.0, run=run) + # Create a regression with this field change + create_regression(session, ts, title='Assigned Regression', + state=10, field_changes=[fc]) + fc_uuid = fc.uuid + session.commit() + session.close() + return fc_uuid + + +def _create_ignored_fieldchange(app): + """Create a field change that is ignored (has a ChangeIgnore row). + Returns the field change UUID. + """ + db = app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + machine = create_machine( + session, ts, name=f'fc-ign-{uuid.uuid4().hex[:8]}') + order1 = create_order( + session, ts, revision=f'fc-i-o1-{uuid.uuid4().hex[:8]}') + order2 = create_order( + session, ts, revision=f'fc-i-o2-{uuid.uuid4().hex[:8]}') + test = create_test( + session, ts, name=f'fc/ignored/{uuid.uuid4().hex[:8]}') + run = create_run(session, ts, machine, order2) + field = ts.sample_fields[0] + fc = create_fieldchange(session, ts, order1, order2, machine, test, + field, old_value=5.0, new_value=10.0, run=run) + ignore = ts.ChangeIgnore(fc) + session.add(ignore) + fc_uuid = fc.uuid + session.commit() + session.close() + return fc_uuid + + +# ========================================================================== +# Field Change List (Unassigned) Tests +# ========================================================================== + +class TestFieldChangeList(unittest.TestCase): + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_list_returns_200(self): + resp = self.client.get(PREFIX + '/field-changes') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertIn('items', data) + self.assertIsInstance(data['items'], list) + + def test_list_has_pagination_envelope(self): + resp = self.client.get(PREFIX + '/field-changes') + data = resp.get_json() + self.assertIn('cursor', data) + self.assertIn('next', data['cursor']) + self.assertIn('previous', data['cursor']) + + def test_list_contains_unassigned_fc(self): + fc_uuid = _create_unassigned_fieldchange(self.app) + resp = self.client.get(PREFIX + '/field-changes') + data = resp.get_json() + uuids = [fc['uuid'] for fc in data['items']] + self.assertIn(fc_uuid, uuids) + + def test_list_excludes_assigned_fc(self): + """Field changes with a RegressionIndicator should NOT appear.""" + assigned_uuid = _create_assigned_fieldchange(self.app) + resp = self.client.get(PREFIX + '/field-changes') + data = resp.get_json() + uuids = [fc['uuid'] for fc in data['items']] + self.assertNotIn(assigned_uuid, uuids) + + def test_list_excludes_ignored_fc(self): + """Field changes with a ChangeIgnore should NOT appear.""" + ignored_uuid = _create_ignored_fieldchange(self.app) + resp = self.client.get(PREFIX + '/field-changes') + data = resp.get_json() + uuids = [fc['uuid'] for fc in data['items']] + self.assertNotIn(ignored_uuid, uuids) + + def test_list_item_has_expected_fields(self): + _create_unassigned_fieldchange(self.app) + resp = self.client.get(PREFIX + '/field-changes') + data = resp.get_json() + if data['items']: + item = data['items'][0] + self.assertIn('uuid', item) + self.assertIn('test', item) + self.assertIn('machine', item) + self.assertIn('metric', item) + self.assertIn('old_value', item) + self.assertIn('new_value', item) + self.assertIn('start_order', item) + self.assertIn('end_order', item) + self.assertIn('run_uuid', item) + + def test_list_filter_by_machine(self): + """Filter unassigned field changes by machine name.""" + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + unique = uuid.uuid4().hex[:8] + machine_name = f'fc-filter-m-{unique}' + machine = create_machine(session, ts, name=machine_name) + o1 = create_order( + session, ts, revision=f'fc-fm-o1-{uuid.uuid4().hex[:8]}') + o2 = create_order( + session, ts, revision=f'fc-fm-o2-{uuid.uuid4().hex[:8]}') + test = create_test( + session, ts, name=f'fc/filter-m/{uuid.uuid4().hex[:8]}') + run = create_run(session, ts, machine, o2) + field = ts.sample_fields[0] + fc = create_fieldchange(session, ts, o1, o2, machine, test, + field, run=run) + fc_uuid = fc.uuid + session.commit() + session.close() + + resp = self.client.get( + PREFIX + f'/field-changes?machine={machine_name}') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + for item in data['items']: + self.assertEqual(item['machine'], machine_name) + uuids = [item['uuid'] for item in data['items']] + self.assertIn(fc_uuid, uuids) + + def test_list_filter_by_test(self): + """Filter unassigned field changes by test name.""" + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + unique = uuid.uuid4().hex[:8] + test_name = f'fc/filter-t/{unique}' + machine = create_machine( + session, ts, name=f'fc-ft-m-{uuid.uuid4().hex[:8]}') + o1 = create_order( + session, ts, revision=f'fc-ft-o1-{uuid.uuid4().hex[:8]}') + o2 = create_order( + session, ts, revision=f'fc-ft-o2-{uuid.uuid4().hex[:8]}') + test = create_test(session, ts, name=test_name) + run = create_run(session, ts, machine, o2) + field = ts.sample_fields[0] + fc = create_fieldchange(session, ts, o1, o2, machine, test, + field, run=run) + fc_uuid = fc.uuid + session.commit() + session.close() + + resp = self.client.get( + PREFIX + f'/field-changes?test={test_name}') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + for item in data['items']: + self.assertEqual(item['test'], test_name) + uuids = [item['uuid'] for item in data['items']] + self.assertIn(fc_uuid, uuids) + + def test_list_filter_by_metric(self): + """Filter unassigned field changes by metric name.""" + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + unique = uuid.uuid4().hex[:8] + machine = create_machine( + session, ts, name=f'fc-filter-met-{unique}') + o1 = create_order( + session, ts, revision=f'fc-fmet-o1-{uuid.uuid4().hex[:8]}') + o2 = create_order( + session, ts, revision=f'fc-fmet-o2-{uuid.uuid4().hex[:8]}') + test = create_test( + session, ts, name=f'fc/filter-met/{uuid.uuid4().hex[:8]}') + run = create_run(session, ts, machine, o2) + field = ts.sample_fields[0] + fc = create_fieldchange(session, ts, o1, o2, machine, test, + field, run=run) + fc_uuid = fc.uuid + session.commit() + session.close() + + resp = self.client.get( + PREFIX + f'/field-changes?metric={field.name}') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + for item in data['items']: + self.assertEqual(item['metric'], field.name) + uuids = [item['uuid'] for item in data['items']] + self.assertIn(fc_uuid, uuids) + + def test_list_pagination(self): + """Test pagination of unassigned field changes.""" + for _ in range(3): + _create_unassigned_fieldchange(self.app) + resp = self.client.get(PREFIX + '/field-changes?limit=2') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertLessEqual(len(data['items']), 2) + if data['cursor']['next']: + cursor = data['cursor']['next'] + resp2 = self.client.get( + PREFIX + f'/field-changes?limit=2&cursor={cursor}') + self.assertEqual(resp2.status_code, 200) + + def test_invalid_cursor_returns_400(self): + """An invalid cursor string should return 400.""" + resp = self.client.get( + PREFIX + '/field-changes?cursor=not-a-valid-cursor!!!') + self.assertEqual(resp.status_code, 400) + + +# ========================================================================== +# Ignore Tests +# ========================================================================== + +class TestFieldChangeIgnore(unittest.TestCase): + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_ignore_field_change(self): + fc_uuid = _create_unassigned_fieldchange(self.app) + headers = _triage_headers(self.app) + resp = self.client.post( + PREFIX + f'/field-changes/{fc_uuid}/ignore', + headers=headers, + ) + self.assertEqual(resp.status_code, 201) + data = resp.get_json() + self.assertEqual(data['status'], 'ignored') + self.assertEqual(data['field_change_uuid'], fc_uuid) + + def test_ignore_removes_from_unassigned_list(self): + fc_uuid = _create_unassigned_fieldchange(self.app) + headers = _triage_headers(self.app) + + # Ignore it + resp = self.client.post( + PREFIX + f'/field-changes/{fc_uuid}/ignore', + headers=headers, + ) + self.assertEqual(resp.status_code, 201) + + # Verify it's no longer in the unassigned list + resp2 = self.client.get(PREFIX + '/field-changes') + data2 = resp2.get_json() + uuids = [fc['uuid'] for fc in data2['items']] + self.assertNotIn(fc_uuid, uuids) + + def test_ignore_already_ignored_409(self): + fc_uuid = _create_unassigned_fieldchange(self.app) + headers = _triage_headers(self.app) + + # Ignore once + resp = self.client.post( + PREFIX + f'/field-changes/{fc_uuid}/ignore', + headers=headers, + ) + self.assertEqual(resp.status_code, 201) + + # Ignore again -- should be 409 + resp2 = self.client.post( + PREFIX + f'/field-changes/{fc_uuid}/ignore', + headers=headers, + ) + self.assertEqual(resp2.status_code, 409) + + def test_ignore_nonexistent_404(self): + headers = _triage_headers(self.app) + resp = self.client.post( + PREFIX + '/field-changes/nonexistent-uuid/ignore', + headers=headers, + ) + self.assertEqual(resp.status_code, 404) + + def test_ignore_no_auth_401(self): + fc_uuid = _create_unassigned_fieldchange(self.app) + resp = self.client.post( + PREFIX + f'/field-changes/{fc_uuid}/ignore', + ) + self.assertEqual(resp.status_code, 401) + + def test_ignore_read_scope_403(self): + fc_uuid = _create_unassigned_fieldchange(self.app) + headers = make_scoped_headers(self.app, 'read') + resp = self.client.post( + PREFIX + f'/field-changes/{fc_uuid}/ignore', + headers=headers, + ) + self.assertEqual(resp.status_code, 403) + + +# ========================================================================== +# Un-ignore Tests +# ========================================================================== + +class TestFieldChangeUnignore(unittest.TestCase): + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_unignore_field_change(self): + fc_uuid = _create_ignored_fieldchange(self.app) + headers = _triage_headers(self.app) + resp = self.client.delete( + PREFIX + f'/field-changes/{fc_uuid}/ignore', + headers=headers, + ) + self.assertEqual(resp.status_code, 204) + + def test_unignore_restores_to_unassigned_list(self): + fc_uuid = _create_ignored_fieldchange(self.app) + headers = _triage_headers(self.app) + + # Un-ignore it + resp = self.client.delete( + PREFIX + f'/field-changes/{fc_uuid}/ignore', + headers=headers, + ) + self.assertEqual(resp.status_code, 204) + + # Verify it appears in the unassigned list + resp2 = self.client.get(PREFIX + '/field-changes') + data2 = resp2.get_json() + uuids = [fc['uuid'] for fc in data2['items']] + self.assertIn(fc_uuid, uuids) + + def test_unignore_not_ignored_404(self): + """Un-ignoring a field change that's not ignored should return 404.""" + fc_uuid = _create_unassigned_fieldchange(self.app) + headers = _triage_headers(self.app) + resp = self.client.delete( + PREFIX + f'/field-changes/{fc_uuid}/ignore', + headers=headers, + ) + self.assertEqual(resp.status_code, 404) + + def test_unignore_nonexistent_404(self): + headers = _triage_headers(self.app) + resp = self.client.delete( + PREFIX + '/field-changes/nonexistent-uuid/ignore', + headers=headers, + ) + self.assertEqual(resp.status_code, 404) + + def test_unignore_no_auth_401(self): + fc_uuid = _create_ignored_fieldchange(self.app) + resp = self.client.delete( + PREFIX + f'/field-changes/{fc_uuid}/ignore', + ) + self.assertEqual(resp.status_code, 401) + + def test_unignore_read_scope_403(self): + fc_uuid = _create_ignored_fieldchange(self.app) + headers = make_scoped_headers(self.app, 'read') + resp = self.client.delete( + PREFIX + f'/field-changes/{fc_uuid}/ignore', + headers=headers, + ) + self.assertEqual(resp.status_code, 403) + + +class TestFieldChangePagination(unittest.TestCase): + """Exhaustive cursor pagination tests for GET /api/v5/{ts}/field-changes.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + cls._machine_name = f'pag-fc-m-{uuid.uuid4().hex[:8]}' + db = cls.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + machine = create_machine(session, ts, name=cls._machine_name) + o1 = create_order( + session, ts, revision=f'pag-fc-o1-{uuid.uuid4().hex[:8]}') + o2 = create_order( + session, ts, revision=f'pag-fc-o2-{uuid.uuid4().hex[:8]}') + run = create_run(session, ts, machine, o2) + field = ts.sample_fields[0] + for i in range(5): + test = create_test( + session, ts, + name=f'pag-fc/test/{uuid.uuid4().hex[:8]}/{i}') + create_fieldchange(session, ts, o1, o2, machine, test, field, + old_value=float(i), new_value=float(i + 10), + run=run) + session.commit() + session.close() + + def _collect_all_pages(self): + url = PREFIX + f'/field-changes?machine={self._machine_name}&limit=2' + return collect_all_pages(self, self.client, url) + + def test_pagination_collects_all_items(self): + """Paginating through all pages collects all 5 field changes.""" + all_items = self._collect_all_pages() + self.assertEqual(len(all_items), 5) + + def test_no_duplicate_items_across_pages(self): + """No duplicate field change UUIDs across pages.""" + all_items = self._collect_all_pages() + uuids = [item['uuid'] for item in all_items] + self.assertEqual(len(uuids), len(set(uuids))) + + +class TestFieldChangeUnknownParams(unittest.TestCase): + """Test that unknown query parameters are rejected with 400.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_field_changes_list_unknown_param_returns_400(self): + resp = self.client.get(PREFIX + '/field-changes?bogus=1') + self.assertEqual(resp.status_code, 400) + data = resp.get_json() + self.assertIn('bogus', data['error']['message']) + + +# ========================================================================== +# Field Change Creation Tests +# ========================================================================== + +class TestFieldChangeCreate(unittest.TestCase): + """Tests for POST /api/v5/{ts}/field-changes.""" + + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + # Set up shared test data: a machine, test, two orders, and a run. + db = cls.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + + cls._machine_name = f'create-fc-m-{uuid.uuid4().hex[:8]}' + cls._test_name = f'create-fc/test/{uuid.uuid4().hex[:8]}' + cls._start_rev = f'create-fc-o1-{uuid.uuid4().hex[:8]}' + cls._end_rev = f'create-fc-o2-{uuid.uuid4().hex[:8]}' + cls._field_name = ts.sample_fields[0].name + + machine = create_machine(session, ts, name=cls._machine_name) + create_order(session, ts, revision=cls._start_rev) + end_order = create_order(session, ts, revision=cls._end_rev) + create_test(session, ts, name=cls._test_name) + run = create_run(session, ts, machine, end_order) + cls._run_uuid = run.uuid + + session.commit() + session.close() + + def _valid_body(self, **overrides): + """Return a valid POST body dict with optional overrides.""" + body = { + 'machine': self._machine_name, + 'test': self._test_name, + 'metric': self._field_name, + 'old_value': 10.0, + 'new_value': 20.0, + 'start_order': self._start_rev, + 'end_order': self._end_rev, + } + body.update(overrides) + return body + + # -- Happy path -- + + def test_create_field_change_201(self): + """POST with valid body returns 201 and correct fields.""" + headers = _submit_headers(self.app) + headers['Content-Type'] = 'application/json' + body = self._valid_body() + resp = self.client.post( + PREFIX + '/field-changes', + data=json.dumps(body), + headers=headers, + ) + self.assertEqual(resp.status_code, 201) + data = resp.get_json() + self.assertIn('uuid', data) + self.assertEqual(data['machine'], self._machine_name) + self.assertEqual(data['test'], self._test_name) + self.assertEqual(data['metric'], self._field_name) + self.assertAlmostEqual(data['old_value'], 10.0) + self.assertAlmostEqual(data['new_value'], 20.0) + self.assertEqual(data['start_order'], self._start_rev) + self.assertEqual(data['end_order'], self._end_rev) + + def test_create_with_run_uuid(self): + """POST with optional run_uuid returns 201 with run_uuid in response.""" + headers = _submit_headers(self.app) + headers['Content-Type'] = 'application/json' + body = self._valid_body(run_uuid=self._run_uuid) + resp = self.client.post( + PREFIX + '/field-changes', + data=json.dumps(body), + headers=headers, + ) + self.assertEqual(resp.status_code, 201) + data = resp.get_json() + self.assertEqual(data['run_uuid'], self._run_uuid) + + def test_create_without_run_uuid_returns_null(self): + """POST without run_uuid should return run_uuid as None.""" + headers = _submit_headers(self.app) + headers['Content-Type'] = 'application/json' + body = self._valid_body() + resp = self.client.post( + PREFIX + '/field-changes', + data=json.dumps(body), + headers=headers, + ) + self.assertEqual(resp.status_code, 201) + data = resp.get_json() + self.assertIsNone(data['run_uuid']) + + def test_each_create_gets_unique_uuid(self): + """Two POSTs should produce field changes with different UUIDs.""" + headers = _submit_headers(self.app) + headers['Content-Type'] = 'application/json' + body = self._valid_body() + resp1 = self.client.post( + PREFIX + '/field-changes', + data=json.dumps(body), + headers=headers, + ) + resp2 = self.client.post( + PREFIX + '/field-changes', + data=json.dumps(body), + headers=headers, + ) + self.assertEqual(resp1.status_code, 201) + self.assertEqual(resp2.status_code, 201) + self.assertNotEqual( + resp1.get_json()['uuid'], resp2.get_json()['uuid']) + + def test_created_fc_appears_in_list(self): + """A created field change should appear in GET /field-changes.""" + headers = _submit_headers(self.app) + headers['Content-Type'] = 'application/json' + body = self._valid_body() + resp = self.client.post( + PREFIX + '/field-changes', + data=json.dumps(body), + headers=headers, + ) + self.assertEqual(resp.status_code, 201) + created_uuid = resp.get_json()['uuid'] + + # Fetch unassigned list + resp2 = self.client.get(PREFIX + '/field-changes') + self.assertEqual(resp2.status_code, 200) + uuids = [fc['uuid'] for fc in resp2.get_json()['items']] + self.assertIn(created_uuid, uuids) + + # -- Missing required fields -- + + def test_missing_machine_name_400(self): + headers = _submit_headers(self.app) + headers['Content-Type'] = 'application/json' + body = self._valid_body() + del body['machine'] + resp = self.client.post( + PREFIX + '/field-changes', + data=json.dumps(body), + headers=headers, + ) + self.assertEqual(resp.status_code, 422) + + def test_missing_test_name_400(self): + headers = _submit_headers(self.app) + headers['Content-Type'] = 'application/json' + body = self._valid_body() + del body['test'] + resp = self.client.post( + PREFIX + '/field-changes', + data=json.dumps(body), + headers=headers, + ) + self.assertEqual(resp.status_code, 422) + + def test_missing_field_name_400(self): + headers = _submit_headers(self.app) + headers['Content-Type'] = 'application/json' + body = self._valid_body() + del body['metric'] + resp = self.client.post( + PREFIX + '/field-changes', + data=json.dumps(body), + headers=headers, + ) + self.assertEqual(resp.status_code, 422) + + def test_missing_old_value_400(self): + headers = _submit_headers(self.app) + headers['Content-Type'] = 'application/json' + body = self._valid_body() + del body['old_value'] + resp = self.client.post( + PREFIX + '/field-changes', + data=json.dumps(body), + headers=headers, + ) + self.assertEqual(resp.status_code, 422) + + def test_missing_start_order_400(self): + headers = _submit_headers(self.app) + headers['Content-Type'] = 'application/json' + body = self._valid_body() + del body['start_order'] + resp = self.client.post( + PREFIX + '/field-changes', + data=json.dumps(body), + headers=headers, + ) + self.assertEqual(resp.status_code, 422) + + def test_missing_new_value_400(self): + headers = _submit_headers(self.app) + headers['Content-Type'] = 'application/json' + body = self._valid_body() + del body['new_value'] + resp = self.client.post( + PREFIX + '/field-changes', + data=json.dumps(body), + headers=headers, + ) + self.assertEqual(resp.status_code, 422) + + def test_missing_end_order_400(self): + headers = _submit_headers(self.app) + headers['Content-Type'] = 'application/json' + body = self._valid_body() + del body['end_order'] + resp = self.client.post( + PREFIX + '/field-changes', + data=json.dumps(body), + headers=headers, + ) + self.assertEqual(resp.status_code, 422) + + # -- Nonexistent references -- + + def test_nonexistent_machine_404(self): + headers = _submit_headers(self.app) + headers['Content-Type'] = 'application/json' + body = self._valid_body(machine='no-such-machine-xyz') + resp = self.client.post( + PREFIX + '/field-changes', + data=json.dumps(body), + headers=headers, + ) + self.assertEqual(resp.status_code, 404) + + def test_nonexistent_test_404(self): + headers = _submit_headers(self.app) + headers['Content-Type'] = 'application/json' + body = self._valid_body(test='no/such/test/xyz') + resp = self.client.post( + PREFIX + '/field-changes', + data=json.dumps(body), + headers=headers, + ) + self.assertEqual(resp.status_code, 404) + + def test_unknown_field_name_400(self): + headers = _submit_headers(self.app) + headers['Content-Type'] = 'application/json' + body = self._valid_body(metric='no_such_field_xyz') + resp = self.client.post( + PREFIX + '/field-changes', + data=json.dumps(body), + headers=headers, + ) + self.assertEqual(resp.status_code, 400) + + def test_nonexistent_start_order_404(self): + headers = _submit_headers(self.app) + headers['Content-Type'] = 'application/json' + body = self._valid_body(start_order='nonexistent-rev-xyz') + resp = self.client.post( + PREFIX + '/field-changes', + data=json.dumps(body), + headers=headers, + ) + self.assertEqual(resp.status_code, 404) + + def test_nonexistent_end_order_404(self): + headers = _submit_headers(self.app) + headers['Content-Type'] = 'application/json' + body = self._valid_body(end_order='nonexistent-rev-xyz') + resp = self.client.post( + PREFIX + '/field-changes', + data=json.dumps(body), + headers=headers, + ) + self.assertEqual(resp.status_code, 404) + + def test_nonexistent_run_uuid_404(self): + headers = _submit_headers(self.app) + headers['Content-Type'] = 'application/json' + body = self._valid_body(run_uuid='nonexistent-run-uuid-xyz') + resp = self.client.post( + PREFIX + '/field-changes', + data=json.dumps(body), + headers=headers, + ) + self.assertEqual(resp.status_code, 404) + + # -- Invalid body -- + + def test_empty_body_400(self): + headers = _submit_headers(self.app) + headers['Content-Type'] = 'application/json' + resp = self.client.post( + PREFIX + '/field-changes', + data='', + headers=headers, + ) + self.assertIn(resp.status_code, (400, 422)) + + def test_invalid_json_400(self): + headers = _submit_headers(self.app) + headers['Content-Type'] = 'application/json' + resp = self.client.post( + PREFIX + '/field-changes', + data='not json', + headers=headers, + ) + self.assertIn(resp.status_code, (400, 422)) + + # -- Auth -- + + def test_no_auth_401(self): + body = self._valid_body() + resp = self.client.post( + PREFIX + '/field-changes', + data=json.dumps(body), + content_type='application/json', + ) + self.assertEqual(resp.status_code, 401) + + def test_read_scope_403(self): + headers = make_scoped_headers(self.app, 'read') + headers['Content-Type'] = 'application/json' + body = self._valid_body() + resp = self.client.post( + PREFIX + '/field-changes', + data=json.dumps(body), + headers=headers, + ) + self.assertEqual(resp.status_code, 403) + + def test_admin_scope_201(self): + """Admin scope should also be allowed (higher than submit).""" + headers = admin_headers() + headers['Content-Type'] = 'application/json' + body = self._valid_body() + resp = self.client.post( + PREFIX + '/field-changes', + data=json.dumps(body), + headers=headers, + ) + self.assertEqual(resp.status_code, 201) + + +if __name__ == '__main__': + unittest.main(argv=[sys.argv[0]], exit=True) diff --git a/tests/server/api/v5/test_helpers.py b/tests/server/api/v5/test_helpers.py new file mode 100644 index 000000000..5acdf20cc --- /dev/null +++ b/tests/server/api/v5/test_helpers.py @@ -0,0 +1,94 @@ +# Unit tests for v5 API helper functions. +# +# These tests exercise pure helpers that do not require a database or +# Flask application context, so they can run directly with unittest. +# +# RUN: python %s +# END. + +import datetime +import unittest + +from lnt.server.api.v5.helpers import escape_like, parse_datetime + + +class TestParseDatetime(unittest.TestCase): + """Tests for parse_datetime().""" + + def test_naive_datetime_unchanged(self): + """A naive ISO string (no timezone) should be returned as-is.""" + result = parse_datetime('2024-01-15T10:00:00') + self.assertEqual(result, datetime.datetime(2024, 1, 15, 10, 0, 0)) + + def test_utc_timezone(self): + """A datetime with explicit +00:00 offset should remain the same + value after stripping tzinfo (already UTC).""" + result = parse_datetime('2024-01-15T10:00:00+00:00') + self.assertEqual(result, datetime.datetime(2024, 1, 15, 10, 0, 0)) + + def test_z_suffix(self): + """The 'Z' suffix is equivalent to +00:00 (UTC).""" + result = parse_datetime('2024-01-15T10:00:00Z') + self.assertEqual(result, datetime.datetime(2024, 1, 15, 10, 0, 0)) + + def test_positive_offset_converted_to_utc(self): + """+05:00 means the local time is 5 hours ahead of UTC, so + 10:00+05:00 should become 05:00 UTC.""" + result = parse_datetime('2024-01-15T10:00:00+05:00') + self.assertEqual(result, datetime.datetime(2024, 1, 15, 5, 0, 0)) + + def test_negative_offset_converted_to_utc(self): + """-05:00 means the local time is 5 hours behind UTC, so + 10:00-05:00 should become 15:00 UTC.""" + result = parse_datetime('2024-01-15T10:00:00-05:00') + self.assertEqual(result, datetime.datetime(2024, 1, 15, 15, 0, 0)) + + def test_result_is_naive(self): + """The returned datetime must always be naive (no tzinfo).""" + result = parse_datetime('2024-01-15T10:00:00+05:00') + self.assertIsNone(result.tzinfo) + + def test_empty_string_returns_none(self): + self.assertIsNone(parse_datetime('')) + + def test_none_returns_none(self): + self.assertIsNone(parse_datetime(None)) + + def test_invalid_string_returns_none(self): + self.assertIsNone(parse_datetime('not-a-date')) + + +class TestEscapeLike(unittest.TestCase): + """Tests for escape_like().""" + + def test_no_special_chars(self): + """Plain strings should pass through unchanged.""" + self.assertEqual(escape_like('hello'), 'hello') + + def test_percent_escaped(self): + self.assertEqual(escape_like('100%'), '100\\%') + + def test_underscore_escaped(self): + self.assertEqual(escape_like('a_b'), 'a\\_b') + + def test_backslash_escaped(self): + """Backslashes must be escaped so they are not interpreted as the + LIKE escape character.""" + self.assertEqual(escape_like('a\\b'), 'a\\\\b') + + def test_backslash_escaped_before_wildcards(self): + """A backslash followed by a wildcard must produce an escaped + backslash followed by an escaped wildcard — the order of + replacements matters.""" + self.assertEqual(escape_like('a\\%b'), 'a\\\\\\%b') + self.assertEqual(escape_like('a\\_b'), 'a\\\\\\_b') + + def test_all_special_chars_together(self): + self.assertEqual(escape_like('\\%_'), '\\\\\\%\\_') + + def test_empty_string(self): + self.assertEqual(escape_like(''), '') + + +if __name__ == '__main__': + unittest.main() diff --git a/tests/server/api/v5/test_integration.py b/tests/server/api/v5/test_integration.py new file mode 100644 index 000000000..627427c9c --- /dev/null +++ b/tests/server/api/v5/test_integration.py @@ -0,0 +1,537 @@ +# End-to-end integration tests for the v5 REST API. +# +# These tests exercise multi-endpoint workflows to verify that the +# endpoints work together correctly, unlike the per-endpoint unit tests. +# +# RUN: rm -rf %t.instance %t.pg.log +# RUN: %{utils}/with_postgres.sh %t.pg.log \ +# RUN: %{utils}/with_temporary_instance.py %t.instance \ +# RUN: -- python %s %t.instance +# END. + +import json +import sys +import os +import unittest +import uuid + +sys.path.insert(0, os.path.dirname(__file__)) +from v5_test_helpers import create_app, create_client, admin_headers + + +TS = 'nts' +PREFIX = f'/api/v5/{TS}' + + +def _make_submission_payload(machine_name=None, revision=None, + tests=None): + """Build a valid v2-format JSON submission payload.""" + if machine_name is None: + machine_name = f'integ-machine-{uuid.uuid4().hex[:8]}' + if revision is None: + revision = f'r{uuid.uuid4().hex[:8]}' + if tests is None: + tests = [ + { + 'name': 'test.suite/benchmark1', + 'execution_time': [0.1234, 0.1235], + }, + { + 'name': 'test.suite/benchmark2', + 'compile_time': 13.12, + 'execution_time': 0.2135, + }, + ] + + return json.dumps({ + 'format_version': '2', + 'machine': { + 'name': machine_name, + }, + 'run': { + 'start_time': '2024-06-15T10:00:00', + 'end_time': '2024-06-15T10:30:00', + 'llvm_project_revision': revision, + }, + 'tests': tests, + }) + + +# ----------------------------------------------------------------------- +# 1. TestRunSubmissionWorkflow +# ----------------------------------------------------------------------- + +class TestRunSubmissionWorkflow(unittest.TestCase): + """Submit a run, then verify it via multiple GET endpoints. + + This workflow exercises: + POST /runs (submit) + GET /runs (list) + GET /runs/{uuid} (detail) + GET /runs/{uuid}/samples (samples) + GET /machines (implicit machine creation) + GET /tests (implicit test creation) + """ + + app = None + client = None + + # Shared state populated by setUpClass + _machine_name = None + _revision = None + _run_uuid = None + + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + cls._machine_name = f'submit-wf-{uuid.uuid4().hex[:8]}' + cls._revision = f'r{uuid.uuid4().hex[:8]}' + payload = _make_submission_payload( + machine_name=cls._machine_name, + revision=cls._revision, + ) + resp = cls.client.post( + PREFIX + '/runs', + data=payload, + content_type='application/json', + headers=admin_headers(), + ) + data = resp.get_json() + cls._run_uuid = data.get('run_uuid') + + def test_01_submission_succeeded(self): + """The run submission should have returned a valid UUID.""" + self.assertIsNotNone( + self._run_uuid, + "Run submission did not return a run_uuid") + uuid.UUID(self._run_uuid, version=4) + + def test_02_run_appears_in_list(self): + """The submitted run appears in the run list endpoint.""" + resp = self.client.get( + PREFIX + f'/runs?machine={self._machine_name}') + self.assertEqual(resp.status_code, 200, + f"GET /runs returned {resp.status_code}") + data = resp.get_json() + uuids = [item['uuid'] for item in data['items']] + self.assertIn(self._run_uuid, uuids, + "Submitted run not found in run list") + + def test_03_run_detail_is_correct(self): + """GET /runs/{uuid} returns the expected detail.""" + resp = self.client.get(PREFIX + f'/runs/{self._run_uuid}') + self.assertEqual(resp.status_code, 200, + f"GET /runs/{uuid} returned {resp.status_code}") + data = resp.get_json() + self.assertEqual(data['uuid'], self._run_uuid, + "Run detail UUID mismatch") + self.assertEqual(data['machine'], self._machine_name, + "Run detail machine name mismatch") + self.assertIn('order', data, + "Run detail missing 'order'") + self.assertEqual( + data['order'].get('llvm_project_revision'), self._revision, + "Run detail order revision mismatch") + self.assertIn('start_time', data) + self.assertIn('end_time', data) + + def test_04_run_samples_returned(self): + """GET /runs/{uuid}/samples returns the submitted samples.""" + resp = self.client.get( + PREFIX + f'/runs/{self._run_uuid}/samples') + self.assertEqual(resp.status_code, 200, + f"GET /runs/{uuid}/samples returned {resp.status_code}") + data = resp.get_json() + self.assertIn('items', data, + "Samples response missing 'items'") + # We submitted 2 tests, each with samples. The import pipeline + # creates one Sample row per (run, test, repetition) combination. + # benchmark1 has 2 execution_time values, benchmark2 has 1. + self.assertGreater(len(data['items']), 0, + "No samples returned for the submitted run") + + test_names = [s['test'] for s in data['items']] + # The import pipeline may prefix test names with the suite name. + has_benchmark1 = any('benchmark1' in n for n in test_names) + has_benchmark2 = any('benchmark2' in n for n in test_names) + self.assertTrue(has_benchmark1, + f"benchmark1 not found in samples: {test_names}") + self.assertTrue(has_benchmark2, + f"benchmark2 not found in samples: {test_names}") + + def test_05_machine_created_implicitly(self): + """The machine is implicitly created by the run submission.""" + resp = self.client.get( + PREFIX + f'/machines/{self._machine_name}') + self.assertEqual(resp.status_code, 200, + f"Machine '{self._machine_name}' not found after run submission") + data = resp.get_json() + self.assertEqual(data['name'], self._machine_name) + + def test_06_tests_created_implicitly(self): + """The test entities are implicitly created by the run submission.""" + resp = self.client.get( + PREFIX + '/tests?name_contains=benchmark1') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + names = [t['name'] for t in data['items']] + has_benchmark1 = any('benchmark1' in n for n in names) + self.assertTrue(has_benchmark1, + f"benchmark1 test not found in tests list: {names}") + + +# ----------------------------------------------------------------------- +# 2. TestAPIKeyLifecycle +# ----------------------------------------------------------------------- + +class TestAPIKeyLifecycle(unittest.TestCase): + """Create an API key, use it, revoke it, verify rejection. + + This workflow exercises: + POST /admin/api-keys (create key) + GET /api/v5/ (read with new key) + POST /runs (submit with new key) + DELETE /admin/api-keys/{prefix} (revoke key) + GET /admin/api-keys (verify 401 after revocation) + """ + + app = None + client = None + + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_api_key_full_lifecycle(self): + """Create, use, revoke, and verify rejection of an API key.""" + # Step 1: Create a submit-scoped key via admin endpoint + create_resp = self.client.post( + '/api/v5/admin/api-keys', + json={'name': 'lifecycle-key', 'scope': 'submit'}, + headers=admin_headers(), + ) + self.assertEqual(create_resp.status_code, 201, + f"Failed to create API key: {create_resp.get_data(as_text=True)}") + created = create_resp.get_json() + raw_token = created['key'] + prefix = created['prefix'] + key_headers = {'Authorization': f'Bearer {raw_token}'} + + # Step 2: Use the new key on a read endpoint -- should succeed + read_resp = self.client.get('/api/v5/', headers=key_headers) + self.assertEqual(read_resp.status_code, 200, + "New submit key cannot read discovery endpoint") + + # Step 3: Use the new key to submit a run (within its scope) + payload = _make_submission_payload() + submit_resp = self.client.post( + PREFIX + '/runs', + data=payload, + content_type='application/json', + headers=key_headers, + ) + self.assertIn(submit_resp.status_code, [201, 301], + "Submit-scoped key failed to submit a run: %d" + % submit_resp.status_code) + + # Step 4: Revoke the key + revoke_resp = self.client.delete( + f'/api/v5/admin/api-keys/{prefix}', + headers=admin_headers(), + ) + self.assertEqual(revoke_resp.status_code, 204, + "Failed to revoke API key") + + # Step 5: Using the revoked key on an admin endpoint yields 401 + # (admin endpoints require auth, revoked key is inactive) + reject_resp = self.client.get( + '/api/v5/admin/api-keys', headers=key_headers) + self.assertEqual(reject_resp.status_code, 401, + "Revoked key was not rejected: got %d" + % reject_resp.status_code) + + +# ----------------------------------------------------------------------- +# 3. TestMachineCRUDWorkflow +# ----------------------------------------------------------------------- + +class TestMachineCRUDWorkflow(unittest.TestCase): + """Create, submit runs, rename, and delete a machine. + + This workflow exercises: + POST /machines (create) + POST /runs (submit run to machine) + GET /machines/{name}/runs (list runs) + PATCH /machines/{name} (rename) + GET /machines/{old_name} (verify 404) + GET /machines/{new_name} (verify accessible) + DELETE /machines/{name} (delete with cascade) + """ + + app = None + client = None + + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_machine_crud_workflow(self): + """Full create-update-delete lifecycle for a machine.""" + original_name = f'crud-machine-{uuid.uuid4().hex[:8]}' + new_name = f'crud-renamed-{uuid.uuid4().hex[:8]}' + + # Step 1: Create a machine explicitly + create_resp = self.client.post( + PREFIX + '/machines', + json={'name': original_name, 'info': {'os': 'linux'}}, + headers=admin_headers(), + ) + self.assertEqual(create_resp.status_code, 201, + f"Failed to create machine: {create_resp.get_data(as_text=True)}") + self.assertEqual(create_resp.get_json()['name'], original_name) + + # Step 2: Submit a run to this machine + payload = _make_submission_payload(machine_name=original_name) + submit_resp = self.client.post( + PREFIX + '/runs', + data=payload, + content_type='application/json', + headers=admin_headers(), + ) + submit_data = submit_resp.get_json() + run_uuid = submit_data.get('run_uuid') + self.assertIsNotNone(run_uuid, + "Run submission did not return a run_uuid") + + # Step 3: List the machine's runs + runs_resp = self.client.get( + PREFIX + f'/machines/{original_name}/runs') + self.assertEqual(runs_resp.status_code, 200) + runs_data = runs_resp.get_json() + run_uuids = [r['uuid'] for r in runs_data['items']] + self.assertIn(run_uuid, run_uuids, + "Submitted run not in machine runs list") + + # Step 4: Rename the machine + rename_resp = self.client.patch( + PREFIX + f'/machines/{original_name}', + json={'name': new_name}, + headers=admin_headers(), + ) + self.assertEqual(rename_resp.status_code, 200, + f"Rename failed: {rename_resp.get_data(as_text=True)}") + self.assertEqual(rename_resp.get_json()['name'], new_name) + location = rename_resp.headers.get('Location') + self.assertIsNotNone(location, + "Rename did not return Location header") + self.assertIn(new_name, location) + + # Step 5: Old name returns 404 + old_resp = self.client.get( + PREFIX + f'/machines/{original_name}') + self.assertEqual(old_resp.status_code, 404, + "Old machine name still accessible: %d" + % old_resp.status_code) + + # Step 6: New name returns the machine + new_resp = self.client.get( + PREFIX + f'/machines/{new_name}') + self.assertEqual(new_resp.status_code, 200, + "New machine name not accessible") + self.assertEqual(new_resp.get_json()['name'], new_name) + + # Step 7: Runs are still accessible under the renamed machine + runs_resp2 = self.client.get( + PREFIX + f'/machines/{new_name}/runs') + self.assertEqual(runs_resp2.status_code, 200) + run_uuids2 = [r['uuid'] for r in runs_resp2.get_json()['items']] + self.assertIn(run_uuid, run_uuids2, + "Run missing after machine rename") + + # Step 8: Delete the machine (cascading) + delete_resp = self.client.delete( + PREFIX + f'/machines/{new_name}', + headers=admin_headers(), + ) + self.assertEqual(delete_resp.status_code, 204, + f"Delete failed: {delete_resp.status_code}") + + # Step 9: Machine is gone + gone_resp = self.client.get( + PREFIX + f'/machines/{new_name}') + self.assertEqual(gone_resp.status_code, 404, + "Machine still found after deletion") + + # Step 10: The run is also gone (cascading delete) + run_resp = self.client.get(PREFIX + f'/runs/{run_uuid}') + self.assertEqual(run_resp.status_code, 404, + "Run still exists after machine deletion") + + +# ----------------------------------------------------------------------- +# 4. TestDiscoveryNavigability +# ----------------------------------------------------------------------- + +class TestDiscoveryNavigability(unittest.TestCase): + """Follow every link from the discovery endpoint and verify 200. + + This workflow exercises: + GET /api/v5/ (discovery) + GET each link in the discovery response + """ + + app = None + client = None + + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_all_discovery_links_resolve(self): + """Every link in the discovery response should return 200.""" + disco_resp = self.client.get('/api/v5/') + self.assertEqual(disco_resp.status_code, 200, + "Discovery endpoint returned %d" + % disco_resp.status_code) + data = disco_resp.get_json() + + self.assertIn('test_suites', data) + self.assertGreater(len(data['test_suites']), 0, + "No test suites in discovery response") + + for suite in data['test_suites']: + self.assertIn('name', suite) + self.assertIn('links', suite) + suite_name = suite['name'] + + for link_name, url in suite['links'].items(): + # The /query endpoint requires a mandatory 'metric' + # parameter, so a bare GET returns 422 by design. + # Skip it in the navigability check. + if link_name == 'query': + continue + resp = self.client.get(url) + self.assertEqual( + resp.status_code, 200, + f"Link '{link_name}' ({url}) for suite '{suite_name}' " + f"returned {resp.status_code}") + + def test_discovery_nts_suite_has_all_expected_links(self): + """The 'nts' suite should have all the expected resource links.""" + disco_resp = self.client.get('/api/v5/') + data = disco_resp.get_json() + + nts_suites = [s for s in data['test_suites'] if s['name'] == 'nts'] + self.assertEqual(len(nts_suites), 1, + "Expected exactly one 'nts' suite") + links = nts_suites[0]['links'] + + expected_keys = { + 'machines', 'orders', 'runs', 'tests', + 'regressions', 'field_changes', 'query', + } + self.assertEqual(set(links.keys()), expected_keys, + "Discovery links mismatch") + + +# ----------------------------------------------------------------------- +# 6. TestCORSOnAllEndpoints +# ----------------------------------------------------------------------- + +class TestCORSOnAllEndpoints(unittest.TestCase): + """Verify CORS headers are present on various endpoint types. + + This workflow exercises the CORS middleware across: + GET /api/v5/ (discovery) + GET /api/v5/{ts}/machines (list) + GET /api/v5/{ts}/runs (list) + POST /api/v5/{ts}/runs (write) + DELETE /api/v5/{ts}/machines/nonexistent (error response) + """ + + app = None + client = None + + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def _assert_cors(self, resp, context): + """Assert that the CORS allow-origin header is present.""" + self.assertEqual( + resp.headers.get('Access-Control-Allow-Origin'), '*', + f"Missing CORS header on {context} (status {resp.status_code})") + + def test_cors_on_discovery(self): + """CORS header on GET /api/v5/.""" + resp = self.client.get('/api/v5/') + self._assert_cors(resp, 'GET /api/v5/') + + def test_cors_on_machine_list(self): + """CORS header on GET /machines.""" + resp = self.client.get(PREFIX + '/machines') + self._assert_cors(resp, 'GET /machines') + + def test_cors_on_run_list(self): + """CORS header on GET /runs.""" + resp = self.client.get(PREFIX + '/runs') + self._assert_cors(resp, 'GET /runs') + + def test_cors_on_run_submit(self): + """CORS header on POST /runs.""" + payload = _make_submission_payload() + resp = self.client.post( + PREFIX + '/runs', + data=payload, + content_type='application/json', + headers=admin_headers(), + ) + self._assert_cors(resp, 'POST /runs') + + def test_cors_on_error_response(self): + """CORS header present even on 404 error responses.""" + resp = self.client.get( + PREFIX + '/machines/nonexistent-cors-test-xyz') + self.assertEqual(resp.status_code, 404) + self._assert_cors(resp, 'GET /machines/nonexistent (404)') + + def test_cors_on_delete_error(self): + """CORS header present on 401 (unauthenticated DELETE).""" + resp = self.client.delete( + PREFIX + '/machines/nonexistent-cors-del') + # Should be 401 (no auth) -- but we care about the header + self._assert_cors(resp, 'DELETE /machines/nonexistent (no auth)') + + def test_cors_on_options_preflight(self): + """OPTIONS preflight request returns proper CORS headers.""" + resp = self.client.options( + PREFIX + '/machines', + headers={ + 'Origin': 'https://example.com', + 'Access-Control-Request-Method': 'GET', + }, + ) + self._assert_cors(resp, 'OPTIONS /machines') + # Verify the Allow-Methods and Allow-Headers are present + self.assertIn( + 'GET', + resp.headers.get('Access-Control-Allow-Methods', ''), + "OPTIONS response missing GET in Allow-Methods") + self.assertIn( + 'Authorization', + resp.headers.get('Access-Control-Allow-Headers', ''), + "OPTIONS response missing Authorization in Allow-Headers") + + +if __name__ == '__main__': + unittest.main(argv=[sys.argv[0]], exit=True) diff --git a/tests/server/api/v5/test_machines.py b/tests/server/api/v5/test_machines.py new file mode 100644 index 000000000..ec817bb9c --- /dev/null +++ b/tests/server/api/v5/test_machines.py @@ -0,0 +1,762 @@ +# Tests for the v5 machine endpoints. +# +# RUN: rm -rf %t.instance %t.pg.log +# RUN: %{utils}/with_postgres.sh %t.pg.log \ +# RUN: %{utils}/with_temporary_instance.py %t.instance \ +# RUN: -- python %s %t.instance +# END. + +import datetime +import sys +import os +import unittest +import uuid + +sys.path.insert(0, os.path.dirname(__file__)) +from v5_test_helpers import ( + create_app, create_client, admin_headers, make_scoped_headers, + create_machine, create_order, create_run, collect_all_pages, + create_test, create_fieldchange, create_regression, +) + + +TS = 'nts' +PREFIX = f'/api/v5/{TS}' + + +class TestMachineList(unittest.TestCase): + """Tests for GET /api/v5/{ts}/machines.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_list_empty(self): + """Empty list when no machines exist initially (or just returns 200).""" + resp = self.client.get(PREFIX + '/machines') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertIn('items', data) + self.assertIsInstance(data['items'], list) + + def test_list_has_pagination_envelope(self): + resp = self.client.get(PREFIX + '/machines') + data = resp.get_json() + self.assertIn('cursor', data) + self.assertIn('next', data['cursor']) + self.assertIn('previous', data['cursor']) + + def test_list_with_total(self): + """Offset-paginated lists include a total count.""" + resp = self.client.get(PREFIX + '/machines') + data = resp.get_json() + self.assertIn('total', data) + self.assertIsInstance(data['total'], int) + + +class TestMachineCreate(unittest.TestCase): + """Tests for POST /api/v5/{ts}/machines.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_create_machine(self): + """Create a machine and verify 201 response.""" + name = f'create-test-{uuid.uuid4().hex[:8]}' + resp = self.client.post( + PREFIX + '/machines', + json={'name': name}, + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 201) + data = resp.get_json() + self.assertEqual(data['name'], name) + + def test_create_machine_with_info(self): + """Create a machine with metadata.""" + name = f'create-info-{uuid.uuid4().hex[:8]}' + resp = self.client.post( + PREFIX + '/machines', + json={'name': name, 'info': {'arch': 'x86_64', 'os': 'linux'}}, + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 201) + data = resp.get_json() + self.assertEqual(data['name'], name) + self.assertIn('info', data) + self.assertEqual(data['info'].get('arch'), 'x86_64') + + def test_create_machine_appears_in_list(self): + """Newly created machine appears in the list.""" + name = f'create-list-{uuid.uuid4().hex[:8]}' + self.client.post( + PREFIX + '/machines', + json={'name': name}, + headers=admin_headers(), + ) + resp = self.client.get(PREFIX + '/machines') + data = resp.get_json() + names = [m['name'] for m in data['items']] + self.assertIn(name, names) + + def test_create_machine_no_auth_401(self): + """Creating without auth should return 401.""" + resp = self.client.post( + PREFIX + '/machines', + json={'name': 'no-auth-test'}, + ) + self.assertEqual(resp.status_code, 401) + + def test_create_machine_read_scope_403(self): + """Creating with read scope should return 403.""" + headers = make_scoped_headers(self.app, 'read') + resp = self.client.post( + PREFIX + '/machines', + json={'name': 'read-only-test'}, + headers=headers, + ) + self.assertEqual(resp.status_code, 403) + + def test_create_machine_missing_name_422(self): + """Creating without name should return 422 (schema validation).""" + resp = self.client.post( + PREFIX + '/machines', + json={}, + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 422) + + def test_create_duplicate_409(self): + """Creating a machine with a duplicate name should return 409.""" + name = f'dup-test-{uuid.uuid4().hex[:8]}' + self.client.post( + PREFIX + '/machines', + json={'name': name}, + headers=admin_headers(), + ) + resp = self.client.post( + PREFIX + '/machines', + json={'name': name}, + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 409) + + +class TestMachineDetail(unittest.TestCase): + """Tests for GET /api/v5/{ts}/machines/{machine_name}.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_get_machine_detail(self): + """Get machine detail by name.""" + name = f'detail-test-{uuid.uuid4().hex[:8]}' + self.client.post( + PREFIX + '/machines', + json={'name': name, 'info': {'foo': 'bar'}}, + headers=admin_headers(), + ) + resp = self.client.get(PREFIX + f'/machines/{name}') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertEqual(data['name'], name) + self.assertIn('info', data) + + def test_get_nonexistent_404(self): + """Getting a nonexistent machine should return 404.""" + resp = self.client.get( + PREFIX + '/machines/nonexistent-machine-xyz') + self.assertEqual(resp.status_code, 404) + + +class TestMachineDetailETag(unittest.TestCase): + """ETag tests for GET /api/v5/{ts}/machines/{machine_name}.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_etag_present_on_detail(self): + """Machine detail response should include an ETag header.""" + name = f'etag-present-{uuid.uuid4().hex[:8]}' + self.client.post( + PREFIX + '/machines', + json={'name': name}, + headers=admin_headers(), + ) + resp = self.client.get(PREFIX + f'/machines/{name}') + self.assertEqual(resp.status_code, 200) + etag = resp.headers.get('ETag') + self.assertIsNotNone(etag) + self.assertTrue(etag.startswith('W/"')) + + def test_etag_304_on_match(self): + """Sending If-None-Match with the same ETag returns 304.""" + name = f'etag-304-{uuid.uuid4().hex[:8]}' + self.client.post( + PREFIX + '/machines', + json={'name': name}, + headers=admin_headers(), + ) + resp = self.client.get(PREFIX + f'/machines/{name}') + etag = resp.headers.get('ETag') + + resp2 = self.client.get( + PREFIX + f'/machines/{name}', + headers={'If-None-Match': etag}, + ) + self.assertEqual(resp2.status_code, 304) + + def test_etag_200_on_mismatch(self): + """Sending If-None-Match with a different ETag returns 200.""" + name = f'etag-200-{uuid.uuid4().hex[:8]}' + self.client.post( + PREFIX + '/machines', + json={'name': name}, + headers=admin_headers(), + ) + resp = self.client.get( + PREFIX + f'/machines/{name}', + headers={'If-None-Match': 'W/"stale-etag-value"'}, + ) + self.assertEqual(resp.status_code, 200) + self.assertIsNotNone(resp.get_json()) + + +class TestMachineUpdate(unittest.TestCase): + """Tests for PATCH /api/v5/{ts}/machines/{machine_name}.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_rename_machine(self): + """Rename a machine and verify Location header.""" + old_name = f'rename-old-{uuid.uuid4().hex[:8]}' + new_name = f'rename-new-{uuid.uuid4().hex[:8]}' + self.client.post( + PREFIX + '/machines', + json={'name': old_name}, + headers=admin_headers(), + ) + resp = self.client.patch( + PREFIX + f'/machines/{old_name}', + json={'name': new_name}, + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertEqual(data['name'], new_name) + # Check Location header + location = resp.headers.get('Location') + self.assertIsNotNone(location) + self.assertIn(new_name, location) + + def test_update_info(self): + """Update machine info without rename.""" + name = f'update-info-{uuid.uuid4().hex[:8]}' + self.client.post( + PREFIX + '/machines', + json={'name': name}, + headers=admin_headers(), + ) + resp = self.client.patch( + PREFIX + f'/machines/{name}', + json={'info': {'key': 'value'}}, + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertEqual(data['info'].get('key'), 'value') + + def test_rename_to_existing_409(self): + """Renaming to an existing name should return 409.""" + name1 = f'rename-dup-a-{uuid.uuid4().hex[:8]}' + name2 = f'rename-dup-b-{uuid.uuid4().hex[:8]}' + self.client.post( + PREFIX + '/machines', json={'name': name1}, + headers=admin_headers(), + ) + self.client.post( + PREFIX + '/machines', json={'name': name2}, + headers=admin_headers(), + ) + resp = self.client.patch( + PREFIX + f'/machines/{name1}', + json={'name': name2}, + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 409) + + +class TestMachineDelete(unittest.TestCase): + """Tests for DELETE /api/v5/{ts}/machines/{machine_name}.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_delete_machine(self): + """Delete machine and verify 204, then verify it's gone.""" + name = f'delete-test-{uuid.uuid4().hex[:8]}' + self.client.post( + PREFIX + '/machines', + json={'name': name}, + headers=admin_headers(), + ) + resp = self.client.delete( + PREFIX + f'/machines/{name}', + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 204) + + # Verify it's gone + resp = self.client.get(PREFIX + f'/machines/{name}') + self.assertEqual(resp.status_code, 404) + + def test_delete_machine_with_runs(self): + """Delete machine that has runs -- verify cascading deletion works.""" + name = f'delete-runs-{uuid.uuid4().hex[:8]}' + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + machine = create_machine(session, ts, name=name) + order = create_order(session, ts, revision='del-rev-1') + create_run(session, ts, machine, order) + session.commit() + session.close() + + resp = self.client.delete( + PREFIX + f'/machines/{name}', + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 204) + + # Verify machine is gone + resp = self.client.get(PREFIX + f'/machines/{name}') + self.assertEqual(resp.status_code, 404) + + def test_delete_machine_with_regression_indicators(self): + """Delete machine whose FieldChanges are linked to RegressionIndicators. + + This verifies that the delete handler cleans up RegressionIndicator + rows (which have an FK to FieldChange) before cascading deletion of + the machine's runs and field changes. Without the cleanup, Postgres + would raise an FK violation. + """ + name = f'delete-ri-{uuid.uuid4().hex[:8]}' + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + + # Create machine, two orders, a run, a test, a field change, + # and a regression with an indicator pointing to that field change. + machine = create_machine(session, ts, name=name) + order1 = create_order(session, ts, revision=f'ri-rev1-{name}') + order2 = create_order(session, ts, revision=f'ri-rev2-{name}') + run = create_run(session, ts, machine, order2) + test = create_test( + session, ts, name=f'ri/test/{uuid.uuid4().hex[:8]}') + field = ts.sample_fields[0] + fc = create_fieldchange(session, ts, order1, order2, machine, test, + field, old_value=1.0, new_value=2.0, run=run) + create_regression( + session, ts, title=f'Reg for {name}', field_changes=[fc]) + + # Verify the indicator exists. + ri_count = session.query(ts.RegressionIndicator).filter( + ts.RegressionIndicator.field_change_id == fc.id + ).count() + self.assertEqual(ri_count, 1) + + session.commit() + session.close() + + # Delete the machine via the API. + resp = self.client.delete( + PREFIX + f'/machines/{name}', + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 204) + + # Verify machine is gone. + resp = self.client.get(PREFIX + f'/machines/{name}') + self.assertEqual(resp.status_code, 404) + + def test_delete_nonexistent_404(self): + """Deleting a nonexistent machine should return 404.""" + resp = self.client.delete( + PREFIX + '/machines/nonexistent-del-xyz', + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 404) + + +class TestMachineRuns(unittest.TestCase): + """Tests for GET /api/v5/{ts}/machines/{machine_name}/runs.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_list_runs_for_machine(self): + """List runs for a machine.""" + name = f'runs-list-{uuid.uuid4().hex[:8]}' + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + machine = create_machine(session, ts, name=name) + order = create_order(session, ts, revision='run-rev-1') + create_run(session, ts, machine, order, + start_time=datetime.datetime(2024, 6, 1, 12, 0, 0), + end_time=datetime.datetime(2024, 6, 1, 12, 30, 0)) + session.commit() + session.close() + + resp = self.client.get(PREFIX + f'/machines/{name}/runs') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertIn('items', data) + self.assertGreater(len(data['items']), 0) + # Verify run fields + item = data['items'][0] + self.assertIn('uuid', item) + self.assertIn('order', item) + self.assertIn('start_time', item) + self.assertIn('end_time', item) + + def test_list_runs_empty(self): + """Machine with no runs returns empty list.""" + name = f'runs-empty-{uuid.uuid4().hex[:8]}' + self.client.post( + PREFIX + '/machines', + json={'name': name}, + headers=admin_headers(), + ) + resp = self.client.get(PREFIX + f'/machines/{name}/runs') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertEqual(len(data['items']), 0) + + def test_list_runs_pagination(self): + """Test pagination of runs for a machine.""" + name = f'runs-page-{uuid.uuid4().hex[:8]}' + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + machine = create_machine(session, ts, name=name) + # Create 3 runs + for i in range(3): + order = create_order(session, ts, revision=f'page-rev-{i}') + create_run(session, ts, machine, order, + start_time=datetime.datetime(2024, 1, 1 + i, 12, 0, 0)) + session.commit() + session.close() + + # Request with limit=2 + resp = self.client.get( + PREFIX + f'/machines/{name}/runs?limit=2') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertEqual(len(data['items']), 2) + self.assertIsNotNone(data['cursor']['next']) + + # Follow the cursor + cursor = data['cursor']['next'] + resp2 = self.client.get( + PREFIX + f'/machines/{name}/runs?limit=2&cursor={cursor}') + self.assertEqual(resp2.status_code, 200) + data2 = resp2.get_json() + self.assertEqual(len(data2['items']), 1) + self.assertIsNone(data2['cursor']['next']) + + def test_list_runs_after_filter(self): + """Filter runs by after datetime.""" + name = f'runs-after-{uuid.uuid4().hex[:8]}' + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + machine = create_machine(session, ts, name=name) + order1 = create_order(session, ts, revision='after-rev-1') + create_run(session, ts, machine, order1, + start_time=datetime.datetime(2024, 1, 1, 12, 0, 0)) + order2 = create_order(session, ts, revision='after-rev-2') + create_run(session, ts, machine, order2, + start_time=datetime.datetime(2024, 6, 1, 12, 0, 0)) + session.commit() + session.close() + + resp = self.client.get( + PREFIX + f'/machines/{name}/runs?after=2024-03-01T00:00:00') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertEqual(len(data['items']), 1) + + def test_list_runs_before_filter(self): + """Filter runs by before datetime.""" + name = f'runs-before-{uuid.uuid4().hex[:8]}' + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + machine = create_machine(session, ts, name=name) + order1 = create_order(session, ts, revision='before-rev-1') + create_run(session, ts, machine, order1, + start_time=datetime.datetime(2024, 1, 1, 12, 0, 0)) + order2 = create_order(session, ts, revision='before-rev-2') + create_run(session, ts, machine, order2, + start_time=datetime.datetime(2024, 6, 1, 12, 0, 0)) + session.commit() + session.close() + + resp = self.client.get( + PREFIX + f'/machines/{name}/runs?before=2024-03-01T00:00:00') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertEqual(len(data['items']), 1) + + def test_list_runs_sort_descending(self): + """Sort runs by -start_time returns newest first.""" + name = f'runs-sort-{uuid.uuid4().hex[:8]}' + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + machine = create_machine(session, ts, name=name) + for month in (1, 4, 7): + order = create_order( + session, ts, + revision=f'sort-rev-{month}-{uuid.uuid4().hex[:6]}') + create_run(session, ts, machine, order, + start_time=datetime.datetime(2024, month, 1, 12, 0, 0)) + session.commit() + session.close() + + # Default order (ascending by ID) + resp_default = self.client.get( + PREFIX + f'/machines/{name}/runs') + self.assertEqual(resp_default.status_code, 200) + default_times = [ + item['start_time'] for item in resp_default.get_json()['items']] + + # Descending by start_time + resp_sorted = self.client.get( + PREFIX + f'/machines/{name}/runs?sort=-start_time') + self.assertEqual(resp_sorted.status_code, 200) + sorted_times = [ + item['start_time'] for item in resp_sorted.get_json()['items']] + + self.assertEqual(len(sorted_times), 3) + self.assertEqual(sorted_times, list(reversed(default_times))) + + def test_list_runs_nonexistent_machine_404(self): + """Listing runs for a nonexistent machine should return 404.""" + resp = self.client.get( + PREFIX + '/machines/nonexistent-machine-runs/runs') + self.assertEqual(resp.status_code, 404) + + def test_invalid_cursor_returns_400(self): + """An invalid cursor string should return 400.""" + name = f'cursor-bad-{uuid.uuid4().hex[:8]}' + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + create_machine(session, ts, name=name) + session.commit() + session.close() + + resp = self.client.get( + PREFIX + f'/machines/{name}/runs?cursor=not-a-valid-cursor!!!') + self.assertEqual(resp.status_code, 400) + + +class TestMachineRunsPagination(unittest.TestCase): + """Exhaustive cursor pagination tests for GET /api/v5/{ts}/machines/{name}/runs.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + cls._machine_name = f'pag-mruns-{uuid.uuid4().hex[:8]}' + db = cls.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + machine = create_machine(session, ts, name=cls._machine_name) + for i in range(5): + order = create_order( + session, ts, + revision=f'pag-mr-rev-{uuid.uuid4().hex[:6]}-{i}') + create_run(session, ts, machine, order, + start_time=datetime.datetime(2024, 1, 1 + i, 12, 0, 0)) + session.commit() + session.close() + + def _collect_all_pages(self): + url = PREFIX + f'/machines/{self._machine_name}/runs?limit=2' + return collect_all_pages(self, self.client, url) + + def test_pagination_collects_all_items(self): + """Paginating through all pages collects all 5 runs.""" + all_items = self._collect_all_pages() + self.assertEqual(len(all_items), 5) + + def test_no_duplicate_items_across_pages(self): + """No duplicate run UUIDs across pages.""" + all_items = self._collect_all_pages() + uuids = [item['uuid'] for item in all_items] + self.assertEqual(len(uuids), len(set(uuids))) + + +class TestMachineFilter(unittest.TestCase): + """Test machine list filtering.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_filter_name_contains(self): + """Filter machines by name_contains.""" + unique = uuid.uuid4().hex[:8] + name = f'filter-contains-{unique}' + self.client.post( + PREFIX + '/machines', + json={'name': name}, + headers=admin_headers(), + ) + resp = self.client.get( + PREFIX + f'/machines?name_contains={unique}') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertGreater(len(data['items']), 0) + for m in data['items']: + self.assertIn(unique, m['name']) + + def test_filter_name_prefix(self): + """Filter machines by name_prefix.""" + unique = uuid.uuid4().hex[:8] + prefix = f'prefix-{unique}' + name = f'{prefix}-machine' + self.client.post( + PREFIX + '/machines', + json={'name': name}, + headers=admin_headers(), + ) + resp = self.client.get( + PREFIX + f'/machines?name_prefix={prefix}') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertGreater(len(data['items']), 0) + for m in data['items']: + self.assertTrue(m['name'].startswith(prefix)) + + +class TestMachineUnknownParams(unittest.TestCase): + """Test that unknown query parameters are rejected with 400.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_machines_list_unknown_param_returns_400(self): + resp = self.client.get(PREFIX + '/machines?bogus=1') + self.assertEqual(resp.status_code, 400) + data = resp.get_json() + self.assertIn('bogus', data['error']['message']) + + def test_machines_list_typo_param_returns_400(self): + resp = self.client.get(PREFIX + '/machines?name_contain=foo') + self.assertEqual(resp.status_code, 400) + data = resp.get_json() + self.assertIn('name_contain', data['error']['message']) + + def test_machine_detail_unknown_param_returns_400(self): + name = f'unk-det-{uuid.uuid4().hex[:8]}' + self.client.post( + PREFIX + '/machines', + json={'name': name}, + headers=admin_headers(), + ) + resp = self.client.get(PREFIX + f'/machines/{name}?bogus=1') + self.assertEqual(resp.status_code, 400) + + def test_machine_runs_unknown_param_returns_400(self): + name = f'unk-runs-{uuid.uuid4().hex[:8]}' + self.client.post( + PREFIX + '/machines', + json={'name': name}, + headers=admin_headers(), + ) + resp = self.client.get( + PREFIX + f'/machines/{name}/runs?bogus=1') + self.assertEqual(resp.status_code, 400) + + +class TestDuplicateMachineNames(unittest.TestCase): + """Tests that duplicate machine names produce 409 Conflict. + + Machine names are NOT unique in the DB. When a lookup-by-name finds + more than one row the API must return 409 (not silently pick one). + """ + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + # Insert two machines with the same name directly in the DB + cls.dup_name = f'dup-machine-{uuid.uuid4().hex[:8]}' + db = cls.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + create_machine(session, ts, name=cls.dup_name) + create_machine(session, ts, name=cls.dup_name) + session.commit() + session.close() + + def test_get_detail_returns_409(self): + """GET /machines/{name} returns 409 when name is ambiguous.""" + resp = self.client.get(PREFIX + f'/machines/{self.dup_name}') + self.assertEqual(resp.status_code, 409) + data = resp.get_json() + self.assertIn('Multiple machines', data['error']['message']) + + def test_patch_returns_409(self): + """PATCH /machines/{name} returns 409 when name is ambiguous.""" + resp = self.client.patch( + PREFIX + f'/machines/{self.dup_name}', + json={'info': {'key': 'value'}}, + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 409) + data = resp.get_json() + self.assertIn('Multiple machines', data['error']['message']) + + def test_delete_returns_409(self): + """DELETE /machines/{name} returns 409 when name is ambiguous.""" + resp = self.client.delete( + PREFIX + f'/machines/{self.dup_name}', + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 409) + data = resp.get_json() + self.assertIn('Multiple machines', data['error']['message']) + + def test_get_runs_returns_409(self): + """GET /machines/{name}/runs returns 409 when name is ambiguous.""" + resp = self.client.get( + PREFIX + f'/machines/{self.dup_name}/runs') + self.assertEqual(resp.status_code, 409) + data = resp.get_json() + self.assertIn('Multiple machines', data['error']['message']) + + +if __name__ == '__main__': + unittest.main(argv=[sys.argv[0]], exit=True) diff --git a/tests/server/api/v5/test_orders.py b/tests/server/api/v5/test_orders.py new file mode 100644 index 000000000..8d4030a18 --- /dev/null +++ b/tests/server/api/v5/test_orders.py @@ -0,0 +1,645 @@ +# Tests for the v5 order endpoints. +# +# RUN: rm -rf %t.instance %t.pg.log +# RUN: %{utils}/with_postgres.sh %t.pg.log \ +# RUN: %{utils}/with_temporary_instance.py %t.instance \ +# RUN: -- python %s %t.instance +# END. + +import sys +import os +import unittest +import uuid + +sys.path.insert(0, os.path.dirname(__file__)) +from v5_test_helpers import ( + create_app, create_client, admin_headers, make_scoped_headers, + create_order, collect_all_pages, +) + + +TS = 'nts' +PREFIX = f'/api/v5/{TS}' + + +class TestOrderList(unittest.TestCase): + """Tests for GET /api/v5/{ts}/orders.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_list_returns_200(self): + resp = self.client.get(PREFIX + '/orders') + self.assertEqual(resp.status_code, 200) + + def test_list_has_pagination_envelope(self): + resp = self.client.get(PREFIX + '/orders') + data = resp.get_json() + self.assertIn('items', data) + self.assertIn('cursor', data) + self.assertIn('next', data['cursor']) + self.assertIn('previous', data['cursor']) + + def test_list_returns_orders(self): + """Create an order via DB and verify it appears in the list.""" + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + rev = f'list-{uuid.uuid4().hex[:8]}' + create_order(session, ts, revision=rev) + session.commit() + session.close() + + resp = self.client.get(PREFIX + '/orders') + data = resp.get_json() + self.assertGreater(len(data['items']), 0) + # Each item should have a 'fields' dict + for item in data['items']: + self.assertIn('fields', item) + self.assertIsInstance(item['fields'], dict) + + def test_list_pagination(self): + """Verify cursor pagination works.""" + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + for i in range(3): + create_order(session, ts, + revision=f'page-{uuid.uuid4().hex[:6]}-{i}') + session.commit() + session.close() + + resp = self.client.get(PREFIX + '/orders?limit=1') + data = resp.get_json() + self.assertEqual(len(data['items']), 1) + self.assertIsNotNone(data['cursor']['next']) + + # Follow cursor + cursor = data['cursor']['next'] + resp2 = self.client.get( + PREFIX + f'/orders?limit=1&cursor={cursor}') + self.assertEqual(resp2.status_code, 200) + data2 = resp2.get_json() + self.assertEqual(len(data2['items']), 1) + + def test_list_no_auth_required_for_read(self): + """GET should work without auth headers (unauthenticated reads).""" + resp = self.client.get(PREFIX + '/orders') + self.assertEqual(resp.status_code, 200) + + def test_invalid_cursor_returns_400(self): + """An invalid cursor string should return 400.""" + resp = self.client.get( + PREFIX + '/orders?cursor=not-a-valid-cursor!!!') + self.assertEqual(resp.status_code, 400) + + +class TestOrderCreate(unittest.TestCase): + """Tests for POST /api/v5/{ts}/orders.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_create_order(self): + """Create an order and verify 201 response.""" + rev = f'create-{uuid.uuid4().hex[:8]}' + resp = self.client.post( + PREFIX + '/orders', + json={'llvm_project_revision': rev}, + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 201) + data = resp.get_json() + self.assertIn('fields', data) + self.assertEqual(data['fields']['llvm_project_revision'], rev) + + def test_create_order_includes_prev_next(self): + """Created order response includes prev/next references.""" + rev = f'prevnext-{uuid.uuid4().hex[:8]}' + resp = self.client.post( + PREFIX + '/orders', + json={'llvm_project_revision': rev}, + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 201) + data = resp.get_json() + # prev/next may be None but the keys should be present + self.assertIn('previous_order', data) + self.assertIn('next_order', data) + + def test_create_order_appears_in_list(self): + """Newly created order appears in the order list.""" + rev = f'appear-{uuid.uuid4().hex[:8]}' + self.client.post( + PREFIX + '/orders', + json={'llvm_project_revision': rev}, + headers=admin_headers(), + ) + resp = self.client.get(PREFIX + '/orders') + data = resp.get_json() + revs = [item['fields'].get('llvm_project_revision') + for item in data['items']] + self.assertIn(rev, revs) + + def test_create_duplicate_409(self): + """Creating an order with duplicate field values returns 409.""" + rev = f'dup-{uuid.uuid4().hex[:8]}' + self.client.post( + PREFIX + '/orders', + json={'llvm_project_revision': rev}, + headers=admin_headers(), + ) + resp = self.client.post( + PREFIX + '/orders', + json={'llvm_project_revision': rev}, + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 409) + + def test_create_order_missing_field_400(self): + """Creating without required field returns 400.""" + resp = self.client.post( + PREFIX + '/orders', + json={}, + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 400) + + def test_create_order_no_body_400(self): + """POST without body returns 400.""" + resp = self.client.post( + PREFIX + '/orders', + headers=admin_headers(), + content_type='application/json', + ) + self.assertEqual(resp.status_code, 400) + + def test_create_order_no_auth_401(self): + """Creating without auth should return 401.""" + resp = self.client.post( + PREFIX + '/orders', + json={'llvm_project_revision': 'no-auth'}, + ) + self.assertEqual(resp.status_code, 401) + + def test_create_order_read_scope_403(self): + """Creating with read scope should return 403.""" + headers = make_scoped_headers(self.app, 'read') + resp = self.client.post( + PREFIX + '/orders', + json={'llvm_project_revision': 'read-only'}, + headers=headers, + ) + self.assertEqual(resp.status_code, 403) + + def test_create_order_submit_scope_ok(self): + """Submit scope should be sufficient to create orders.""" + headers = make_scoped_headers(self.app, 'submit') + rev = f'submit-{uuid.uuid4().hex[:8]}' + resp = self.client.post( + PREFIX + '/orders', + json={'llvm_project_revision': rev}, + headers=headers, + ) + self.assertEqual(resp.status_code, 201) + + +class TestOrderDetail(unittest.TestCase): + """Tests for GET /api/v5/{ts}/orders/{order_value}.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_get_order_detail(self): + """Get order detail by primary field value.""" + rev = f'detail-{uuid.uuid4().hex[:8]}' + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + create_order(session, ts, revision=rev) + session.commit() + session.close() + + resp = self.client.get(PREFIX + f'/orders/{rev}') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertIn('fields', data) + self.assertEqual(data['fields']['llvm_project_revision'], rev) + + def test_get_order_includes_prev_next(self): + """Order detail includes previous_order and next_order.""" + rev = f'detail-pn-{uuid.uuid4().hex[:8]}' + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + create_order(session, ts, revision=rev) + session.commit() + session.close() + + resp = self.client.get(PREFIX + f'/orders/{rev}') + data = resp.get_json() + self.assertIn('previous_order', data) + self.assertIn('next_order', data) + + def test_get_nonexistent_404(self): + """Getting a nonexistent order should return 404.""" + resp = self.client.get( + PREFIX + '/orders/nonexistent-order-xyz') + self.assertEqual(resp.status_code, 404) + + def test_order_detail_with_neighbors(self): + """Verify previous/next order references when neighbors exist.""" + # Create two orders via POST so the linked list is maintained + rev1 = f'100{uuid.uuid4().hex[:4]}' + rev2 = f'200{uuid.uuid4().hex[:4]}' + self.client.post( + PREFIX + '/orders', + json={'llvm_project_revision': rev1}, + headers=admin_headers(), + ) + self.client.post( + PREFIX + '/orders', + json={'llvm_project_revision': rev2}, + headers=admin_headers(), + ) + + # At least one of them should have a neighbor + resp1 = self.client.get(PREFIX + f'/orders/{rev1}') + resp2 = self.client.get(PREFIX + f'/orders/{rev2}') + data1 = resp1.get_json() + data2 = resp2.get_json() + + # We can't predict exact ordering, but the response structure + # should be correct + for data in (data1, data2): + self.assertIn('previous_order', data) + self.assertIn('next_order', data) + for neighbor_key in ('previous_order', 'next_order'): + neighbor = data[neighbor_key] + if neighbor is not None: + self.assertIn('fields', neighbor) + self.assertIn('link', neighbor) + + +class TestOrderDetailETag(unittest.TestCase): + """ETag tests for GET /api/v5/{ts}/orders/{order_value}.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_etag_present_on_detail(self): + """Order detail response should include an ETag header.""" + rev = f'etag-present-{uuid.uuid4().hex[:8]}' + self.client.post( + PREFIX + '/orders', + json={'llvm_project_revision': rev}, + headers=admin_headers(), + ) + resp = self.client.get(PREFIX + f'/orders/{rev}') + self.assertEqual(resp.status_code, 200) + etag = resp.headers.get('ETag') + self.assertIsNotNone(etag) + self.assertTrue(etag.startswith('W/"')) + + def test_etag_304_on_match(self): + """Sending If-None-Match with the same ETag returns 304.""" + rev = f'etag-304-{uuid.uuid4().hex[:8]}' + self.client.post( + PREFIX + '/orders', + json={'llvm_project_revision': rev}, + headers=admin_headers(), + ) + resp = self.client.get(PREFIX + f'/orders/{rev}') + etag = resp.headers.get('ETag') + + resp2 = self.client.get( + PREFIX + f'/orders/{rev}', + headers={'If-None-Match': etag}, + ) + self.assertEqual(resp2.status_code, 304) + + def test_etag_200_on_mismatch(self): + """Sending If-None-Match with a different ETag returns 200.""" + rev = f'etag-200-{uuid.uuid4().hex[:8]}' + self.client.post( + PREFIX + '/orders', + json={'llvm_project_revision': rev}, + headers=admin_headers(), + ) + resp = self.client.get( + PREFIX + f'/orders/{rev}', + headers={'If-None-Match': 'W/"stale-etag-value"'}, + ) + self.assertEqual(resp.status_code, 200) + self.assertIsNotNone(resp.get_json()) + + +class TestOrderUpdate(unittest.TestCase): + """Tests for PATCH /api/v5/{ts}/orders/{order_value}.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_patch_order(self): + """PATCH an existing order (currently limited, just confirms 200).""" + rev = f'patch-{uuid.uuid4().hex[:8]}' + self.client.post( + PREFIX + '/orders', + json={'llvm_project_revision': rev}, + headers=admin_headers(), + ) + resp = self.client.patch( + PREFIX + f'/orders/{rev}', + json={'note': 'test'}, + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 200) + + def test_patch_nonexistent_404(self): + """PATCHing a nonexistent order returns 404.""" + resp = self.client.patch( + PREFIX + '/orders/nonexistent-patch-xyz', + json={'note': 'test'}, + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 404) + + def test_patch_no_auth_401(self): + """PATCH without auth returns 401.""" + rev = f'patch-noauth-{uuid.uuid4().hex[:8]}' + self.client.post( + PREFIX + '/orders', + json={'llvm_project_revision': rev}, + headers=admin_headers(), + ) + resp = self.client.patch( + PREFIX + f'/orders/{rev}', + json={'note': 'test'}, + ) + self.assertEqual(resp.status_code, 401) + + def test_patch_read_scope_403(self): + """PATCH with read scope returns 403.""" + rev = f'patch-read-{uuid.uuid4().hex[:8]}' + self.client.post( + PREFIX + '/orders', + json={'llvm_project_revision': rev}, + headers=admin_headers(), + ) + headers = make_scoped_headers(self.app, 'read') + resp = self.client.patch( + PREFIX + f'/orders/{rev}', + json={'note': 'test'}, + headers=headers, + ) + self.assertEqual(resp.status_code, 403) + + +class TestOrderPagination(unittest.TestCase): + """Exhaustive cursor pagination tests for GET /api/v5/{ts}/orders.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + cls._revisions = [] + db = cls.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + for i in range(5): + rev = f'pag-{uuid.uuid4().hex[:8]}-{i}' + create_order(session, ts, revision=rev) + cls._revisions.append(rev) + session.commit() + session.close() + + def _collect_all_pages(self): + url = PREFIX + '/orders?limit=2' + return collect_all_pages(self, self.client, url) + + def test_pagination_collects_all_items(self): + """Paginating through all pages collects all created orders.""" + all_items = self._collect_all_pages() + revisions = [item['fields']['llvm_project_revision'] + for item in all_items] + for rev in self._revisions: + self.assertIn(rev, revisions) + + def test_no_duplicate_items_across_pages(self): + """No duplicate orders across pages.""" + all_items = self._collect_all_pages() + revisions = [item['fields']['llvm_project_revision'] + for item in all_items] + self.assertEqual(len(revisions), len(set(revisions))) + + +class TestOrderUnknownParams(unittest.TestCase): + """Test that unknown query parameters are rejected with 400.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_orders_list_unknown_param_returns_400(self): + resp = self.client.get(PREFIX + '/orders?bogus=1') + self.assertEqual(resp.status_code, 400) + data = resp.get_json() + self.assertIn('bogus', data['error']['message']) + + def test_order_detail_unknown_param_returns_400(self): + rev = f'unk-det-{uuid.uuid4().hex[:8]}' + self.client.post( + PREFIX + '/orders', + json={'llvm_project_revision': rev}, + headers=admin_headers(), + ) + resp = self.client.get(PREFIX + f'/orders/{rev}?bogus=1') + self.assertEqual(resp.status_code, 400) + + +class TestOrderTag(unittest.TestCase): + """Tests for order tagging (tag field on orders).""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def _create_order(self, rev=None, tag=None): + """Helper to create an order, optionally with a tag.""" + if rev is None: + rev = f'tag-{uuid.uuid4().hex[:8]}' + body = {'llvm_project_revision': rev} + if tag is not None: + body['tag'] = tag + resp = self.client.post( + PREFIX + '/orders', + json=body, + headers=admin_headers(), + ) + return resp, rev + + def test_tag_on_create(self): + """POST /orders with tag field sets the tag.""" + resp, rev = self._create_order(tag='release-18.1') + self.assertEqual(resp.status_code, 201) + data = resp.get_json() + self.assertEqual(data['tag'], 'release-18.1') + + def test_tag_appears_in_detail(self): + """Tag appears in GET /orders/{value} detail.""" + _, rev = self._create_order(tag='detail-tag') + resp = self.client.get(PREFIX + f'/orders/{rev}') + self.assertEqual(resp.status_code, 200) + self.assertEqual(resp.get_json()['tag'], 'detail-tag') + + def test_tag_appears_in_list(self): + """Tag appears in GET /orders list items.""" + _, rev = self._create_order(tag='list-tag') + resp = self.client.get(PREFIX + '/orders?tag=list-tag') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertGreater(len(data['items']), 0) + self.assertEqual(data['items'][0]['tag'], 'list-tag') + + def test_tag_default_null(self): + """Orders created without a tag have tag=null.""" + resp, rev = self._create_order() + self.assertEqual(resp.status_code, 201) + self.assertIsNone(resp.get_json()['tag']) + + def test_set_tag_via_patch(self): + """PATCH to set a tag on an existing order.""" + _, rev = self._create_order() + resp = self.client.patch( + PREFIX + f'/orders/{rev}', + json={'tag': 'patched'}, + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 200) + self.assertEqual(resp.get_json()['tag'], 'patched') + + # Verify it persists + detail = self.client.get(PREFIX + f'/orders/{rev}') + self.assertEqual(detail.get_json()['tag'], 'patched') + + def test_clear_tag_via_patch(self): + """PATCH {"tag": null} clears the tag.""" + _, rev = self._create_order(tag='to-clear') + resp = self.client.patch( + PREFIX + f'/orders/{rev}', + json={'tag': None}, + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 200) + self.assertIsNone(resp.get_json()['tag']) + + def test_tag_too_long_on_patch_400(self): + """PATCH with >64 char tag returns 400.""" + _, rev = self._create_order() + resp = self.client.patch( + PREFIX + f'/orders/{rev}', + json={'tag': 'x' * 65}, + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 400) + + def test_tag_too_long_on_create_400(self): + """POST /orders with >64 char tag returns 400.""" + rev = f'tag-long-{uuid.uuid4().hex[:8]}' + resp = self.client.post( + PREFIX + '/orders', + json={'llvm_project_revision': rev, 'tag': 'x' * 65}, + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 400) + + def test_filter_by_tag(self): + """Filter orders by exact tag.""" + unique = uuid.uuid4().hex[:8] + tag_a = f'filter-a-{unique}' + tag_b = f'filter-b-{unique}' + self._create_order(tag=tag_a) + self._create_order(tag=tag_b) + + resp = self.client.get(PREFIX + f'/orders?tag={tag_a}') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertEqual(len(data['items']), 1) + self.assertEqual(data['items'][0]['tag'], tag_a) + + def test_filter_by_tag_prefix(self): + """Filter orders by tag prefix.""" + unique = uuid.uuid4().hex[:8] + prefix = f'pfx-{unique}' + self._create_order(tag=f'{prefix}-18.1') + self._create_order(tag=f'{prefix}-19.0') + self._create_order(tag='other-tag') + + resp = self.client.get(PREFIX + f'/orders?tag_prefix={prefix}') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertEqual(len(data['items']), 2) + for item in data['items']: + self.assertTrue(item['tag'].startswith(prefix)) + + def test_filter_by_nonexistent_tag(self): + """Filtering by a tag that doesn't exist returns empty results.""" + resp = self.client.get( + PREFIX + '/orders?tag=nonexistent-tag-xyz-abc') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertEqual(len(data['items']), 0) + + def test_patch_without_tag_preserves_existing(self): + """PATCH with no tag key leaves the existing tag unchanged.""" + _, rev = self._create_order(tag='keep-me') + resp = self.client.patch( + PREFIX + f'/orders/{rev}', + json={'unrelated': 'data'}, + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 200) + self.assertEqual(resp.get_json()['tag'], 'keep-me') + + def test_non_string_tag_on_create_400(self): + """POST /orders with a non-string tag returns 400.""" + rev = f'tag-int-{uuid.uuid4().hex[:8]}' + resp = self.client.post( + PREFIX + '/orders', + json={'llvm_project_revision': rev, 'tag': 42}, + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 400) + + def test_non_string_tag_on_patch_400(self): + """PATCH with a non-string tag returns 400.""" + _, rev = self._create_order() + resp = self.client.patch( + PREFIX + f'/orders/{rev}', + json={'tag': ['not', 'a', 'string']}, + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 400) + + def test_tag_exactly_64_chars_accepted(self): + """A tag with exactly 64 characters is accepted.""" + tag = 'x' * 64 + resp, rev = self._create_order(tag=tag) + self.assertEqual(resp.status_code, 201) + self.assertEqual(resp.get_json()['tag'], tag) + + +if __name__ == '__main__': + unittest.main(argv=[sys.argv[0]], exit=True) diff --git a/tests/server/api/v5/test_pagination.py b/tests/server/api/v5/test_pagination.py new file mode 100644 index 000000000..1465813b3 --- /dev/null +++ b/tests/server/api/v5/test_pagination.py @@ -0,0 +1,236 @@ +# Tests for the v5 API pagination utilities. +# +# RUN: python %s +# END. + +"""These are pure unit tests that do not require a running LNT instance.""" + +import sys +import os +import unittest + +sys.path.insert(0, os.path.dirname(__file__)) + +from lnt.server.api.v5.pagination import ( + encode_cursor, decode_cursor, cursor_paginate, make_paginated_response, +) + + +class TestCursorEncoding(unittest.TestCase): + def test_encode_decode_roundtrip(self): + for value in [1, 42, 999999]: + cursor = encode_cursor(value) + self.assertEqual(decode_cursor(cursor), value) + + def test_decode_none(self): + self.assertIsNone(decode_cursor(None)) + + def test_decode_empty(self): + self.assertIsNone(decode_cursor('')) + + def test_decode_malformed(self): + self.assertIsNone(decode_cursor('not-valid-base64!@#')) + + def test_encode_returns_string(self): + cursor = encode_cursor(42) + self.assertIsInstance(cursor, str) + + def test_different_ids_produce_different_cursors(self): + c1 = encode_cursor(1) + c2 = encode_cursor(2) + self.assertNotEqual(c1, c2) + + +class TestCursorPaginate(unittest.TestCase): + """Test cursor_paginate with a real SQLAlchemy in-memory SQLite database.""" + + @classmethod + def setUpClass(cls): + from sqlalchemy import create_engine, Column, Integer + from sqlalchemy.ext.declarative import declarative_base + from sqlalchemy.orm import sessionmaker + + cls.engine = create_engine('sqlite:///:memory:') + cls.Base = declarative_base() + + class Item(cls.Base): + __tablename__ = 'items' + id = Column(Integer, primary_key=True) + + cls.Item = Item + cls.Base.metadata.create_all(cls.engine) + cls.Session = sessionmaker(bind=cls.engine) + + def setUp(self): + """Insert 10 items with ids 1..10.""" + self.session = self.Session() + # Clear any leftover rows + self.session.query(self.Item).delete() + for i in range(1, 11): + self.session.add(self.Item(id=i)) + self.session.commit() + + def tearDown(self): + self.session.close() + + # -- ascending (default) ------------------------------------------------- + + def test_ascending_first_page(self): + query = self.session.query(self.Item) + items, next_cursor = cursor_paginate( + query, self.Item.id, limit=3) + ids = [item.id for item in items] + self.assertEqual(ids, [1, 2, 3]) + self.assertIsNotNone(next_cursor) + + def test_ascending_second_page(self): + query = self.session.query(self.Item) + _, cursor = cursor_paginate(query, self.Item.id, limit=3) + items, next_cursor = cursor_paginate( + query, self.Item.id, cursor_str=cursor, limit=3) + ids = [item.id for item in items] + self.assertEqual(ids, [4, 5, 6]) + self.assertIsNotNone(next_cursor) + + def test_ascending_all_pages(self): + """Walk through all pages and collect all items.""" + query = self.session.query(self.Item) + all_ids = [] + cursor = None + for _ in range(20): # safety limit + items, cursor = cursor_paginate( + query, self.Item.id, cursor_str=cursor, limit=3) + all_ids.extend(item.id for item in items) + if cursor is None: + break + self.assertEqual(all_ids, list(range(1, 11))) + + def test_ascending_exact_page_boundary(self): + """When items exactly fill the limit, next page should be empty.""" + query = self.session.query(self.Item) + items, cursor = cursor_paginate(query, self.Item.id, limit=10) + self.assertEqual(len(items), 10) + self.assertIsNone(cursor) + + # -- descending ---------------------------------------------------------- + + def test_descending_first_page(self): + query = self.session.query(self.Item) + items, next_cursor = cursor_paginate( + query, self.Item.id, limit=3, descending=True) + ids = [item.id for item in items] + self.assertEqual(ids, [10, 9, 8]) + self.assertIsNotNone(next_cursor) + + def test_descending_second_page(self): + query = self.session.query(self.Item) + _, cursor = cursor_paginate( + query, self.Item.id, limit=3, descending=True) + items, next_cursor = cursor_paginate( + query, self.Item.id, cursor_str=cursor, limit=3, + descending=True) + ids = [item.id for item in items] + self.assertEqual(ids, [7, 6, 5]) + self.assertIsNotNone(next_cursor) + + def test_descending_all_pages(self): + """Walk through all pages descending and collect all items.""" + query = self.session.query(self.Item) + all_ids = [] + cursor = None + for _ in range(20): # safety limit + items, cursor = cursor_paginate( + query, self.Item.id, cursor_str=cursor, limit=3, + descending=True) + all_ids.extend(item.id for item in items) + if cursor is None: + break + self.assertEqual(all_ids, list(range(10, 0, -1))) + + def test_descending_exact_page_boundary(self): + """When items exactly fill the limit descending, no next page.""" + query = self.session.query(self.Item) + items, cursor = cursor_paginate( + query, self.Item.id, limit=10, descending=True) + self.assertEqual(len(items), 10) + self.assertIsNone(cursor) + + def test_descending_single_item_pages(self): + """Walking one-at-a-time descending yields all items.""" + query = self.session.query(self.Item) + all_ids = [] + cursor = None + for _ in range(20): + items, cursor = cursor_paginate( + query, self.Item.id, cursor_str=cursor, limit=1, + descending=True) + all_ids.extend(item.id for item in items) + if cursor is None: + break + self.assertEqual(all_ids, list(range(10, 0, -1))) + + # -- edge cases ---------------------------------------------------------- + + def test_empty_table_ascending(self): + self.session.query(self.Item).delete() + self.session.commit() + query = self.session.query(self.Item) + items, cursor = cursor_paginate(query, self.Item.id, limit=5) + self.assertEqual(items, []) + self.assertIsNone(cursor) + + def test_empty_table_descending(self): + self.session.query(self.Item).delete() + self.session.commit() + query = self.session.query(self.Item) + items, cursor = cursor_paginate( + query, self.Item.id, limit=5, descending=True) + self.assertEqual(items, []) + self.assertIsNone(cursor) + + def test_limit_clamped_low(self): + """Limit < 1 should be clamped to 1.""" + query = self.session.query(self.Item) + items, _ = cursor_paginate(query, self.Item.id, limit=0) + self.assertEqual(len(items), 1) + + def test_limit_clamped_high(self): + """Limit > 500 should be clamped to 500.""" + query = self.session.query(self.Item) + items, _ = cursor_paginate(query, self.Item.id, limit=9999) + # Only 10 items in the table + self.assertEqual(len(items), 10) + + +class TestPaginatedResponse(unittest.TestCase): + def test_basic_envelope(self): + result = make_paginated_response( + items=[{'id': 1}, {'id': 2}], + next_cursor='abc123', + ) + self.assertIn('items', result) + self.assertIn('cursor', result) + self.assertEqual(result['cursor']['next'], 'abc123') + self.assertIsNone(result['cursor']['previous']) + + def test_no_next_cursor(self): + result = make_paginated_response(items=[], next_cursor=None) + self.assertIsNone(result['cursor']['next']) + + def test_total_included_when_provided(self): + result = make_paginated_response( + items=[], next_cursor=None, total=42) + self.assertEqual(result['total'], 42) + + def test_total_omitted_when_not_provided(self): + result = make_paginated_response(items=[], next_cursor=None) + self.assertNotIn('total', result) + + def test_items_preserved(self): + items = [{'name': 'a'}, {'name': 'b'}] + result = make_paginated_response(items=items, next_cursor=None) + self.assertEqual(result['items'], items) + + +if __name__ == '__main__': + unittest.main(argv=[sys.argv[0]], exit=True) diff --git a/tests/server/api/v5/test_profiles.py b/tests/server/api/v5/test_profiles.py new file mode 100644 index 000000000..6fbd15d64 --- /dev/null +++ b/tests/server/api/v5/test_profiles.py @@ -0,0 +1,389 @@ +# Tests for the v5 profile endpoints. +# +# RUN: rm -rf %t.instance %t.pg.log +# RUN: %{utils}/with_postgres.sh %t.pg.log \ +# RUN: %{utils}/with_temporary_instance.py %t.instance \ +# RUN: -- python %s %t.instance +# END. + +import base64 +import os +import pickle +import sys +import unittest +import uuid +import zlib + +sys.path.insert(0, os.path.dirname(__file__)) +from v5_test_helpers import ( + create_app, create_client, make_scoped_headers, + create_machine, create_order, create_run, create_test, create_sample, +) + +TS = 'nts' +PREFIX = f'/api/v5/{TS}' + +# Sample profile data in the ProfileV1 format +SAMPLE_PROFILE_DATA = { + 'counters': {'cycles': 12345.0, 'branch-misses': 200.0}, + 'disassembly-format': 'raw', + 'functions': { + 'main': { + 'counters': {'cycles': 80.0, 'branch-misses': 10.0}, + 'data': [ + [0x1000, {'cycles': 50.0}, '\tadd r0, r0, r1'], + [0x1004, {'cycles': 30.0}, '\tmov r2, r3'], + ], + }, + 'helper_func': { + 'counters': {'cycles': 20.0, 'branch-misses': 5.0}, + 'data': [ + [0x2000, {'cycles': 20.0}, '\tret'], + ], + }, + }, +} + + +def _make_encoded_profile(profile_data=None): + """Create a base64-encoded profile string suitable for the Profile + constructor. + + Returns a base64-encoded string of zlib-compressed pickled profile data. + """ + if profile_data is None: + profile_data = SAMPLE_PROFILE_DATA + compressed = zlib.compress(pickle.dumps(profile_data)) + return base64.b64encode(compressed).decode('ascii') + + +class _MockConfig(object): + """Mock config object for Profile.__init__. + + Profile.__init__ accesses config.config.profileDir. + """ + def __init__(self, profile_dir): + self.config = self + self.profileDir = profile_dir + + +def _create_sample_with_profile(session, ts, run, test, profile_dir): + """Create a sample with an associated profile record on disk. + + Returns the created sample. + """ + encoded = _make_encoded_profile() + config = _MockConfig(profile_dir) + profile_obj = ts.Profile(encoded, config, test.name) + session.add(profile_obj) + session.flush() + + # Create Sample linked to this profile + sample = ts.Sample(run, test) + sample.profile_id = profile_obj.id + session.add(sample) + session.flush() + return sample + + +def _setup_run_with_profile(app): + """Create a run with a profiled sample. Returns (run_uuid, test_name).""" + db = app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite['nts'] + + machine = create_machine( + session, ts, f'profile-machine-{uuid.uuid4().hex[:8]}') + order = create_order( + session, ts, revision=f'prof-rev-{uuid.uuid4().hex[:8]}') + run = create_run(session, ts, machine, order) + test = create_test( + session, ts, f'test.suite/profiled-{uuid.uuid4().hex[:8]}') + + profile_dir = app.old_config.profileDir + _create_sample_with_profile(session, ts, run, test, profile_dir) + + session.commit() + run_uuid = run.uuid + test_name = test.name + session.close() + return run_uuid, test_name + + +class TestProfileMetadata(unittest.TestCase): + """Tests for GET /api/v5/{ts}/runs/{uuid}/tests/{test_name}/profile.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_profile_metadata(self): + """Get profile metadata with top-level counters.""" + run_uuid, test_name = _setup_run_with_profile(self.app) + + resp = self.client.get( + PREFIX + f'/runs/{run_uuid}/tests/{test_name}/profile') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertEqual(data['test'], test_name) + self.assertIn('counters', data) + self.assertIn('cycles', data['counters']) + self.assertEqual(data['counters']['cycles'], 12345.0) + + def test_profile_nonexistent_run(self): + """404 for a nonexistent run UUID.""" + fake_uuid = str(uuid.uuid4()) + resp = self.client.get( + PREFIX + f'/runs/{fake_uuid}/tests/some.test/profile') + self.assertEqual(resp.status_code, 404) + + def test_profile_nonexistent_test(self): + """404 for a nonexistent test name.""" + # Create a real run + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite['nts'] + machine = create_machine( + session, ts, f'pne-machine-{uuid.uuid4().hex[:8]}') + order = create_order( + session, ts, revision=f'pne-rev-{uuid.uuid4().hex[:8]}') + run = create_run(session, ts, machine, order) + session.commit() + run_uuid = run.uuid + session.close() + + resp = self.client.get( + PREFIX + f'/runs/{run_uuid}/tests/no.such.test/profile') + self.assertEqual(resp.status_code, 404) + + def test_profile_no_profile_data(self): + """404 when the sample exists but has no profile.""" + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite['nts'] + machine = create_machine( + session, ts, f'noprof-machine-{uuid.uuid4().hex[:8]}') + order = create_order( + session, ts, revision=f'noprof-rev-{uuid.uuid4().hex[:8]}') + run = create_run(session, ts, machine, order) + test = create_test( + session, ts, f'test.suite/noprofile-{uuid.uuid4().hex[:8]}') + create_sample(session, ts, run, test) + session.commit() + run_uuid = run.uuid + test_name = test.name + session.close() + + resp = self.client.get( + PREFIX + f'/runs/{run_uuid}/tests/{test_name}/profile') + self.assertEqual(resp.status_code, 404) + + +class TestProfileFunctions(unittest.TestCase): + """Tests for GET /runs/{uuid}/tests/{test_name}/profile/functions.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_function_list(self): + """Get list of functions with counters.""" + run_uuid, test_name = _setup_run_with_profile(self.app) + + resp = self.client.get( + PREFIX + f'/runs/{run_uuid}/tests/{test_name}/profile/functions') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertIn('functions', data) + self.assertIsInstance(data['functions'], list) + self.assertEqual(len(data['functions']), 2) + + fn_names = {f['name'] for f in data['functions']} + self.assertIn('main', fn_names) + self.assertIn('helper_func', fn_names) + + for fn in data['functions']: + self.assertIn('counters', fn) + self.assertIn('length', fn) + self.assertIsInstance(fn['counters'], dict) + + def test_function_list_nonexistent_run(self): + """404 for a nonexistent run UUID.""" + fake_uuid = str(uuid.uuid4()) + resp = self.client.get( + PREFIX + f'/runs/{fake_uuid}/tests/some.test/profile/functions') + self.assertEqual(resp.status_code, 404) + + def test_function_list_no_profile(self): + """404 when sample has no profile.""" + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite['nts'] + machine = create_machine( + session, ts, f'fnlist-machine-{uuid.uuid4().hex[:8]}') + order = create_order( + session, ts, revision=f'fnlist-rev-{uuid.uuid4().hex[:8]}') + run = create_run(session, ts, machine, order) + test = create_test( + session, ts, + f'test.suite/fnlist-noprof-{uuid.uuid4().hex[:8]}') + create_sample(session, ts, run, test) + session.commit() + run_uuid = run.uuid + test_name = test.name + session.close() + + resp = self.client.get( + PREFIX + f'/runs/{run_uuid}/tests/{test_name}/profile/functions') + self.assertEqual(resp.status_code, 404) + + +class TestProfileFunctionDetail(unittest.TestCase): + """Tests for GET /.../profile/functions/{fn_name}.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_function_detail(self): + """Get disassembly for a specific function.""" + run_uuid, test_name = _setup_run_with_profile(self.app) + + resp = self.client.get( + PREFIX + f'/runs/{run_uuid}/tests/{test_name}/profile/functions/main') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertEqual(data['name'], 'main') + self.assertIn('counters', data) + self.assertIn('disassembly_format', data) + self.assertEqual(data['disassembly_format'], 'raw') + self.assertIn('instructions', data) + self.assertIsInstance(data['instructions'], list) + self.assertEqual(len(data['instructions']), 2) + + inst = data['instructions'][0] + self.assertIn('address', inst) + self.assertIn('counters', inst) + self.assertIn('text', inst) + + def test_function_detail_nonexistent_function(self): + """404 for a function name not in the profile.""" + run_uuid, test_name = _setup_run_with_profile(self.app) + + resp = self.client.get( + PREFIX + f'/runs/{run_uuid}/tests/{test_name}/profile/functions/no_such_fn') + self.assertEqual(resp.status_code, 404) + + def test_function_detail_nonexistent_run(self): + """404 for a nonexistent run UUID.""" + fake_uuid = str(uuid.uuid4()) + resp = self.client.get( + PREFIX + f'/runs/{fake_uuid}/tests/some.test/profile/functions/main') + self.assertEqual(resp.status_code, 404) + + def test_function_detail_no_profile(self): + """404 when sample has no profile.""" + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite['nts'] + machine = create_machine( + session, ts, f'fndet-machine-{uuid.uuid4().hex[:8]}') + order = create_order( + session, ts, revision=f'fndet-rev-{uuid.uuid4().hex[:8]}') + run = create_run(session, ts, machine, order) + test = create_test( + session, ts, + f'test.suite/fndet-noprof-{uuid.uuid4().hex[:8]}') + create_sample(session, ts, run, test) + session.commit() + run_uuid = run.uuid + test_name = test.name + session.close() + + resp = self.client.get( + PREFIX + f'/runs/{run_uuid}/tests/{test_name}/profile/functions/main') + self.assertEqual(resp.status_code, 404) + + +class TestProfileAuth(unittest.TestCase): + """Auth tests for profile endpoints (all use @require_scope('read')).""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + cls._run_uuid, cls._test_name = _setup_run_with_profile(cls.app) + + def test_profile_metadata_no_auth_allowed(self): + """Unauthenticated GET for profile metadata is allowed by default.""" + resp = self.client.get( + PREFIX + f'/runs/{self._run_uuid}/tests/{self._test_name}/profile') + self.assertEqual(resp.status_code, 200) + + def test_profile_metadata_read_scope_allowed(self): + """A valid read-scoped token works for profile metadata.""" + headers = make_scoped_headers(self.app, 'read') + resp = self.client.get( + PREFIX + f'/runs/{self._run_uuid}/tests/{self._test_name}/profile', + headers=headers) + self.assertEqual(resp.status_code, 200) + + def test_profile_functions_no_auth_allowed(self): + """Unauthenticated GET for profile functions is allowed by default.""" + resp = self.client.get( + PREFIX + f'/runs/{self._run_uuid}/tests/{self._test_name}/profile/functions') + self.assertEqual(resp.status_code, 200) + + def test_profile_functions_read_scope_allowed(self): + """A valid read-scoped token works for profile functions.""" + headers = make_scoped_headers(self.app, 'read') + resp = self.client.get( + PREFIX + f'/runs/{self._run_uuid}/tests/{self._test_name}/profile/functions', + headers=headers) + self.assertEqual(resp.status_code, 200) + + def test_profile_function_detail_no_auth_allowed(self): + """Unauthenticated GET for function detail is allowed by default.""" + resp = self.client.get( + PREFIX + f'/runs/{self._run_uuid}/tests/{self._test_name}/profile/functions/main') + self.assertEqual(resp.status_code, 200) + + def test_profile_function_detail_read_scope_allowed(self): + """A valid read-scoped token works for function detail.""" + headers = make_scoped_headers(self.app, 'read') + resp = self.client.get( + PREFIX + f'/runs/{self._run_uuid}/tests/{self._test_name}/profile/functions/main', + headers=headers) + self.assertEqual(resp.status_code, 200) + + +class TestProfileUnknownParams(unittest.TestCase): + """Test that unknown query parameters are rejected with 400.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + cls._run_uuid, cls._test_name = _setup_run_with_profile(cls.app) + + def test_profile_metadata_unknown_param_returns_400(self): + resp = self.client.get( + PREFIX + f'/runs/{self._run_uuid}/tests/{self._test_name}/profile?bogus=1') + self.assertEqual(resp.status_code, 400) + + def test_profile_functions_unknown_param_returns_400(self): + resp = self.client.get( + PREFIX + f'/runs/{self._run_uuid}/tests/{self._test_name}/profile/functions?bogus=1') + self.assertEqual(resp.status_code, 400) + + def test_profile_function_detail_unknown_param_returns_400(self): + resp = self.client.get( + PREFIX + f'/runs/{self._run_uuid}/tests/{self._test_name}/profile/functions/main?bogus=1') + self.assertEqual(resp.status_code, 400) + + +if __name__ == '__main__': + unittest.main(argv=[sys.argv[0]], exit=True) diff --git a/tests/server/api/v5/test_query.py b/tests/server/api/v5/test_query.py new file mode 100644 index 000000000..5684f1a45 --- /dev/null +++ b/tests/server/api/v5/test_query.py @@ -0,0 +1,1363 @@ +# Tests for the v5 query endpoint (GET /api/v5/{ts}/query). +# +# RUN: rm -rf %t.instance %t.pg.log +# RUN: %{utils}/with_postgres.sh %t.pg.log \ +# RUN: %{utils}/with_temporary_instance.py %t.instance \ +# RUN: -- python %s %t.instance +# END. + +import datetime +import sys +import os +import unittest +import uuid + +sys.path.insert(0, os.path.dirname(__file__)) +from v5_test_helpers import ( + create_app, create_client, + create_machine, create_order, create_run, create_test, create_sample, +) + +TS = 'nts' +PREFIX = f'/api/v5/{TS}' + + +def _setup_query_data(app, machine_name, test_name, num_points=5): + """Create a machine, test, and several runs with samples. + + Returns a dict with the created entities for assertions. + """ + db = app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + + machine = create_machine(session, ts, name=machine_name) + test = create_test(session, ts, name=test_name) + + runs = [] + orders = [] + for i in range(num_points): + order = create_order(session, ts, revision=str(100 + i)) + run = create_run( + session, ts, machine, order, + start_time=datetime.datetime(2024, 1, 1 + i, 12, 0, 0), + end_time=datetime.datetime(2024, 1, 1 + i, 12, 30, 0), + ) + # Create sample with execution_time value + create_sample( + session, ts, run, test, + execution_time=float(i + 1) * 1.5, + ) + runs.append(run) + orders.append(order) + + run_uuids = [r.uuid for r in runs] + session.commit() + session.close() + + return { + 'machine': machine_name, + 'test': test_name, + 'run_uuids': run_uuids, + 'num_points': num_points, + } + + +class TestQueryNotFound(unittest.TestCase): + """Tests for 404 responses when entities don't exist.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_nonexistent_machine_returns_404(self): + resp = self.client.get( + PREFIX + '/query?machine=nonexistent-machine-xyz' + '&test=some_test&metric=execution_time') + self.assertEqual(resp.status_code, 404) + data = resp.get_json() + self.assertIn('error', data) + + def test_nonexistent_test_returns_404(self): + # Create a real machine so only the test is missing + unique = uuid.uuid4().hex[:8] + name = f'series-nf-test-{unique}' + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + create_machine(session, ts, name=name) + session.commit() + session.close() + + resp = self.client.get( + PREFIX + f'/query?machine={name}' + '&test=nonexistent-test-xyz&metric=execution_time') + self.assertEqual(resp.status_code, 404) + + def test_nonexistent_field_returns_400(self): + unique = uuid.uuid4().hex[:8] + mname = f'series-nf-field-m-{unique}' + tname = f'series-nf-field-t/{unique}' + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + create_machine(session, ts, name=mname) + create_test(session, ts, name=tname) + session.commit() + session.close() + + resp = self.client.get( + PREFIX + f'/query?machine={mname}' + f'&test={tname}&metric=nonexistent_field') + self.assertEqual(resp.status_code, 400) + + +class TestQueryValidQuery(unittest.TestCase): + """Tests for valid queries that return data.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + unique = uuid.uuid4().hex[:8] + cls._data = _setup_query_data( + cls.app, + machine_name=f'series-valid-m-{unique}', + test_name=f'series-valid-t/{unique}', + num_points=5, + ) + + def test_returns_200(self): + d = self._data + resp = self.client.get( + PREFIX + f'/query?machine={d['machine']}&test={d['test']}&metric=execution_time') + self.assertEqual(resp.status_code, 200) + + def test_returns_items(self): + d = self._data + resp = self.client.get( + PREFIX + f'/query?machine={d['machine']}&test={d['test']}&metric=execution_time') + data = resp.get_json() + self.assertIn('items', data) + self.assertEqual(len(data['items']), d['num_points']) + + def test_data_point_structure(self): + """Each data point must have all required fields.""" + d = self._data + resp = self.client.get( + PREFIX + f'/query?machine={d['machine']}&test={d['test']}&metric=execution_time') + data = resp.get_json() + for item in data['items']: + self.assertIn('test', item) + self.assertIn('machine', item) + self.assertIn('metric', item) + self.assertIn('value', item) + self.assertIn('order', item) + self.assertIn('run_uuid', item) + self.assertIn('timestamp', item) + self.assertIsInstance(item['value'], (int, float)) + self.assertIsInstance(item['order'], dict) + self.assertIsInstance(item['run_uuid'], str) + self.assertEqual(item['test'], d['test']) + self.assertEqual(item['machine'], d['machine']) + self.assertEqual(item['metric'], 'execution_time') + + def test_order_has_field_names(self): + """Order dict should contain order field names as keys.""" + d = self._data + resp = self.client.get( + PREFIX + f'/query?machine={d['machine']}&test={d['test']}&metric=execution_time') + data = resp.get_json() + for item in data['items']: + # NTS suite has llvm_project_revision + self.assertIn('llvm_project_revision', item['order']) + + def test_run_uuids_are_valid(self): + """All run_uuid values should be from the runs we created.""" + d = self._data + resp = self.client.get( + PREFIX + f'/query?machine={d['machine']}&test={d['test']}&metric=execution_time') + data = resp.get_json() + returned_uuids = {item['run_uuid'] for item in data['items']} + expected_uuids = set(d['run_uuids']) + self.assertEqual(returned_uuids, expected_uuids) + + def test_values_are_correct(self): + """Values should match what we inserted.""" + d = self._data + resp = self.client.get( + PREFIX + f'/query?machine={d['machine']}&test={d['test']}&metric=execution_time') + data = resp.get_json() + values = sorted([item['value'] for item in data['items']]) + expected = sorted([float(i + 1) * 1.5 for i in range(d['num_points'])]) + self.assertEqual(values, expected) + + def test_cursor_envelope(self): + """Response should have cursor with next and previous.""" + d = self._data + resp = self.client.get( + PREFIX + f'/query?machine={d['machine']}&test={d['test']}&metric=execution_time') + data = resp.get_json() + self.assertIn('cursor', data) + self.assertIn('next', data['cursor']) + self.assertIn('previous', data['cursor']) + + def test_no_auth_required_for_read(self): + """Query endpoint should work without auth (read scope).""" + d = self._data + resp = self.client.get( + PREFIX + f'/query?machine={d['machine']}&test={d['test']}&metric=execution_time') + self.assertEqual(resp.status_code, 200) + + +class TestQueryEmptyResult(unittest.TestCase): + """Tests for queries that match no data.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_valid_entities_no_samples_returns_empty(self): + """When machine/test/field exist but no samples match, return empty.""" + unique = uuid.uuid4().hex[:8] + mname = f'series-empty-m-{unique}' + tname = f'series-empty-t/{unique}' + + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + create_machine(session, ts, name=mname) + create_test(session, ts, name=tname) + session.commit() + session.close() + + resp = self.client.get( + PREFIX + f'/query?machine={mname}&test={tname}&metric=execution_time') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertEqual(len(data['items']), 0) + self.assertIsNone(data['cursor']['next']) + + +class TestQueryOrdering(unittest.TestCase): + """Tests that data points are returned in order.""" + + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + unique = uuid.uuid4().hex[:8] + mname = f'query-order-m-{unique}' + tname = f'query-order-t/{unique}' + + db = cls.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + + machine = create_machine(session, ts, name=mname) + test = create_test(session, ts, name=tname) + + # Create orders in sequential revision order so Order.id matches + revisions = ['100', '200', '300', '400', '500'] + for rev in revisions: + order = create_order(session, ts, revision=rev) + run = create_run( + session, ts, machine, order, + start_time=datetime.datetime(2024, 1, 1, 12, 0, 0), + ) + create_sample( + session, ts, run, test, + execution_time=float(rev), + ) + + session.commit() + session.close() + + cls._data = { + 'machine': mname, + 'test': tname, + 'expected_revisions': ['100', '200', '300', '400', '500'], + } + + def test_data_sorted_by_order(self): + """Data points should be sorted by order (revision) value.""" + d = self._data + resp = self.client.get( + PREFIX + f'/query?machine={d['machine']}&test={d['test']}&metric=execution_time') + data = resp.get_json() + revisions = [ + item['order']['llvm_project_revision'] + for item in data['items'] + ] + self.assertEqual(revisions, d['expected_revisions']) + + +class TestQueryRangeFilters(unittest.TestCase): + """Tests for after_order/before_order and after_time/before_time filtering.""" + + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + unique = uuid.uuid4().hex[:8] + mname = f'query-filter-m-{unique}' + tname = f'query-filter-t/{unique}' + + db = cls.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + + machine = create_machine(session, ts, name=mname) + test = create_test(session, ts, name=tname) + + for i in range(10): + rev = str(100 + i * 10) # 100, 110, ..., 190 + order = create_order(session, ts, revision=rev) + run = create_run( + session, ts, machine, order, + start_time=datetime.datetime(2024, 1, 1 + i, 12, 0, 0), + ) + create_sample( + session, ts, run, test, + execution_time=float(rev), + ) + + session.commit() + session.close() + + cls._data = { + 'machine': mname, + 'test': tname, + } + + def test_after_order_filter(self): + """Only data points after the given order should be returned.""" + d = self._data + url = (PREFIX + f"/query?machine={d['machine']}&test={d['test']}" + "&metric=execution_time&after_order=150") + resp = self.client.get(url) + self.assertEqual(resp.status_code, 200, resp.get_json()) + data = resp.get_json() + self.assertGreater(len(data['items']), 0) + for item in data['items']: + rev = int(item['order']['llvm_project_revision']) + self.assertGreater(rev, 150) + + def test_before_order_filter(self): + """Only data points before the given order should be returned.""" + d = self._data + url = (PREFIX + f"/query?machine={d['machine']}&test={d['test']}" + "&metric=execution_time&before_order=150") + resp = self.client.get(url) + self.assertEqual(resp.status_code, 200, resp.get_json()) + data = resp.get_json() + self.assertGreater(len(data['items']), 0) + for item in data['items']: + rev = int(item['order']['llvm_project_revision']) + self.assertLess(rev, 150) + + def test_after_order_and_before_order_combined(self): + """Combining after_order and before_order narrows the range.""" + d = self._data + url = (PREFIX + f"/query?machine={d['machine']}&test={d['test']}" + "&metric=execution_time&after_order=120&before_order=170") + resp = self.client.get(url) + self.assertEqual(resp.status_code, 200, resp.get_json()) + data = resp.get_json() + for item in data['items']: + rev = int(item['order']['llvm_project_revision']) + self.assertGreater(rev, 120) + self.assertLess(rev, 170) + self.assertGreater(len(data['items']), 0) + + def test_after_order_nonexistent_returns_404(self): + """Filtering with a non-existent order value returns 404.""" + d = self._data + url = (PREFIX + f"/query?machine={d['machine']}&test={d['test']}" + "&metric=execution_time&after_order=999999") + resp = self.client.get(url) + self.assertEqual(resp.status_code, 404) + + def test_before_order_nonexistent_returns_404(self): + """Filtering with a non-existent order value returns 404.""" + d = self._data + url = (PREFIX + f"/query?machine={d['machine']}&test={d['test']}" + "&metric=execution_time&before_order=999999") + resp = self.client.get(url) + self.assertEqual(resp.status_code, 404) + + def test_after_time_filter(self): + """Only data points from runs after the given time should be returned.""" + d = self._data + url = (PREFIX + f"/query?machine={d['machine']}&test={d['test']}" + "&metric=execution_time&after_time=2024-01-06T00:00:00") + resp = self.client.get(url) + self.assertEqual(resp.status_code, 200, resp.get_json()) + data = resp.get_json() + self.assertGreater(len(data['items']), 0) + for item in data['items']: + self.assertGreater(item['timestamp'], '2024-01-06T00:00:00') + + def test_before_time_filter(self): + """Only data points from runs before the given time should be returned.""" + d = self._data + url = (PREFIX + f"/query?machine={d['machine']}&test={d['test']}" + "&metric=execution_time&before_time=2024-01-04T00:00:00") + resp = self.client.get(url) + self.assertEqual(resp.status_code, 200, resp.get_json()) + data = resp.get_json() + self.assertGreater(len(data['items']), 0) + for item in data['items']: + self.assertLess(item['timestamp'], '2024-01-04T00:00:00') + + def test_after_time_and_before_time_combined(self): + """Combining time range filters narrows the results.""" + d = self._data + url = (PREFIX + f"/query?machine={d['machine']}&test={d['test']}" + "&metric=execution_time" + "&after_time=2024-01-03T00:00:00&before_time=2024-01-07T00:00:00") + resp = self.client.get(url) + self.assertEqual(resp.status_code, 200, resp.get_json()) + data = resp.get_json() + self.assertGreater(len(data['items']), 0) + for item in data['items']: + self.assertGreater(item['timestamp'], '2024-01-03T00:00:00') + self.assertLess(item['timestamp'], '2024-01-07T00:00:00') + + def test_order_and_time_filters_compose(self): + """Both order and time filters can be used together.""" + d = self._data + url = (PREFIX + f"/query?machine={d['machine']}&test={d['test']}" + "&metric=execution_time" + "&after_order=120&before_time=2024-01-07T00:00:00") + resp = self.client.get(url) + self.assertEqual(resp.status_code, 200, resp.get_json()) + data = resp.get_json() + for item in data['items']: + rev = int(item['order']['llvm_project_revision']) + self.assertGreater(rev, 120) + self.assertLess(item['timestamp'], '2024-01-07T00:00:00') + + def test_after_time_future_returns_empty(self): + """Filtering with after_time far in the future returns 0 items.""" + d = self._data + url = (PREFIX + f"/query?machine={d['machine']}&test={d['test']}" + "&metric=execution_time&after_time=2027-02-23T15:01:11") + resp = self.client.get(url) + self.assertEqual(resp.status_code, 200, resp.get_json()) + data = resp.get_json() + self.assertEqual(len(data['items']), 0) + + def test_before_time_past_returns_empty(self): + """Filtering with before_time far in the past returns 0 items.""" + d = self._data + url = (PREFIX + f"/query?machine={d['machine']}&test={d['test']}" + "&metric=execution_time&before_time=2020-01-01T00:00:00") + resp = self.client.get(url) + self.assertEqual(resp.status_code, 200, resp.get_json()) + data = resp.get_json() + self.assertEqual(len(data['items']), 0) + + +class TestQueryLimit(unittest.TestCase): + """Tests for the limit parameter.""" + + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + unique = uuid.uuid4().hex[:8] + cls._data = _setup_query_data( + cls.app, + machine_name=f'series-limit-m-{unique}', + test_name=f'series-limit-t/{unique}', + num_points=10, + ) + + def test_limit_reduces_results(self): + d = self._data + resp = self.client.get( + PREFIX + f"/query?machine={d['machine']}&test={d['test']}" + "&metric=execution_time&limit=3") + data = resp.get_json() + self.assertEqual(len(data['items']), 3) + + def test_limit_with_next_cursor(self): + """When limit truncates results, next cursor should be set.""" + d = self._data + resp = self.client.get( + PREFIX + f"/query?machine={d['machine']}&test={d['test']}" + "&metric=execution_time&limit=3") + data = resp.get_json() + self.assertIsNotNone(data['cursor']['next']) + + def test_limit_larger_than_data(self): + """When limit is larger than data, all data returned, no next cursor.""" + d = self._data + resp = self.client.get( + PREFIX + f"/query?machine={d['machine']}&test={d['test']}" + "&metric=execution_time&limit=500") + data = resp.get_json() + self.assertEqual(len(data['items']), d['num_points']) + self.assertIsNone(data['cursor']['next']) + + +class TestQueryPagination(unittest.TestCase): + """Tests for cursor-based pagination.""" + + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + unique = uuid.uuid4().hex[:8] + cls._data = _setup_query_data( + cls.app, + machine_name=f'series-page-m-{unique}', + test_name=f'series-page-t/{unique}', + num_points=7, + ) + + def test_pagination_collects_all_items(self): + """Paginating through all pages should return all data points.""" + d = self._data + all_items = [] + url = (PREFIX + f"/query?machine={d['machine']}&test={d['test']}" + "&metric=execution_time&limit=3") + + # First page + resp = self.client.get(url) + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + all_items.extend(data['items']) + cursor = data['cursor']['next'] + + # Keep fetching until no next cursor + pages = 1 + while cursor: + resp = self.client.get(url + f'&cursor={cursor}') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + all_items.extend(data['items']) + cursor = data['cursor']['next'] + pages += 1 + if pages > 10: + self.fail("Too many pages; infinite loop detected") + + self.assertEqual(len(all_items), d['num_points']) + + def test_no_duplicate_items_across_pages(self): + """Items should not appear on multiple pages.""" + d = self._data + all_uuids = [] + url = (PREFIX + f"/query?machine={d['machine']}&test={d['test']}" + "&metric=execution_time&limit=2") + + resp = self.client.get(url) + data = resp.get_json() + all_uuids.extend(item['run_uuid'] for item in data['items']) + cursor = data['cursor']['next'] + + pages = 1 + while cursor: + resp = self.client.get(url + f'&cursor={cursor}') + data = resp.get_json() + all_uuids.extend(item['run_uuid'] for item in data['items']) + cursor = data['cursor']['next'] + pages += 1 + if pages > 10: + break + + # Check no duplicates + self.assertEqual(len(all_uuids), len(set(all_uuids))) + + def test_invalid_cursor_returns_400(self): + """An invalid cursor string should return 400.""" + d = self._data + resp = self.client.get( + PREFIX + f"/query?machine={d['machine']}&test={d['test']}" + "&metric=execution_time&cursor=not-a-valid-cursor!!!") + self.assertEqual(resp.status_code, 400) + + +def _setup_multi_test_data(app, machine_name, test_names, num_orders=5): + """Create a machine, multiple tests, and samples for each.""" + db = app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + + machine = create_machine(session, ts, name=machine_name) + tests = [create_test(session, ts, name=tn) for tn in test_names] + + for i in range(num_orders): + order = create_order(session, ts, revision=str(1000 + i)) + run = create_run( + session, ts, machine, order, + start_time=datetime.datetime(2024, 6, 1 + i, 12, 0, 0), + ) + for j, test in enumerate(tests): + create_sample( + session, ts, run, test, + execution_time=float((i + 1) * 10 + j), + ) + + session.commit() + session.close() + + return { + 'machine': machine_name, + 'test_names': test_names, + 'num_orders': num_orders, + } + + +class TestQueryOptionalParams(unittest.TestCase): + """Verify each filter parameter is independently optional.""" + + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + unique = uuid.uuid4().hex[:8] + cls._data = _setup_multi_test_data( + cls.app, + machine_name=f'query-opt-m-{unique}', + test_names=[f'query-opt-t1/{unique}', + f'query-opt-t2/{unique}', + f'query-opt-t3/{unique}'], + num_orders=3, + ) + + def test_omitting_test_returns_all_tests(self): + d = self._data + resp = self.client.get( + PREFIX + f"/query?machine={d['machine']}&metric=execution_time") + self.assertEqual(resp.status_code, 200, resp.get_json()) + data = resp.get_json() + returned_tests = {item['test'] for item in data['items']} + self.assertEqual(returned_tests, set(d['test_names'])) + + def test_omitting_machine_returns_data(self): + d = self._data + resp = self.client.get( + PREFIX + f"/query?test={d['test_names'][0]}&metric=execution_time") + self.assertEqual(resp.status_code, 200, resp.get_json()) + data = resp.get_json() + self.assertGreater(len(data['items']), 0) + + def test_omitting_field_returns_422(self): + d = self._data + resp = self.client.get( + PREFIX + f"/query?machine={d['machine']}" + f"&test={d['test_names'][0]}") + self.assertEqual(resp.status_code, 422) + + def test_omitting_all_params_returns_422(self): + resp = self.client.get(PREFIX + '/query') + self.assertEqual(resp.status_code, 422) + + def test_nonexistent_machine_returns_404(self): + resp = self.client.get( + PREFIX + '/query?machine=nonexistent-machine-xyz' + '&metric=execution_time') + self.assertEqual(resp.status_code, 404) + + def test_nonexistent_test_returns_404(self): + resp = self.client.get( + PREFIX + '/query?test=nonexistent-test-xyz' + '&metric=execution_time') + self.assertEqual(resp.status_code, 404) + + def test_nonexistent_field_returns_400(self): + resp = self.client.get( + PREFIX + '/query?metric=nonexistent_field') + self.assertEqual(resp.status_code, 400) + + +class TestQueryResponseShape(unittest.TestCase): + """Response shape is always the same regardless of filters.""" + + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + unique = uuid.uuid4().hex[:8] + cls._data = _setup_multi_test_data( + cls.app, + machine_name=f'query-shape-m-{unique}', + test_names=[f'query-shape-t/{unique}'], + num_orders=3, + ) + + def _assert_item_shape(self, item): + """Assert a single item has all required fields.""" + for key in ('test', 'machine', 'metric', + 'value', 'order', 'run_uuid', 'timestamp'): + self.assertIn(key, item, f"Missing key: {key}") + + def test_items_with_all_filters(self): + d = self._data + resp = self.client.get( + PREFIX + f"/query?machine={d['machine']}" + f"&test={d['test_names'][0]}&metric=execution_time") + data = resp.get_json() + for item in data['items']: + self._assert_item_shape(item) + + def test_items_with_no_filters_returns_422(self): + resp = self.client.get(PREFIX + '/query') + self.assertEqual(resp.status_code, 422) + + def test_items_with_only_machine_returns_422(self): + d = self._data + resp = self.client.get( + PREFIX + f"/query?machine={d['machine']}") + self.assertEqual(resp.status_code, 422) + + +class TestQueryMultiTestPagination(unittest.TestCase): + """Pagination across multiple tests.""" + + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + unique = uuid.uuid4().hex[:8] + cls._data = _setup_multi_test_data( + cls.app, + machine_name=f'query-mtp-m-{unique}', + test_names=[f'query-mtp-t1/{unique}', + f'query-mtp-t2/{unique}', + f'query-mtp-t3/{unique}'], + num_orders=5, + ) + + def test_pagination_collects_all_items(self): + """Paginating should return all 3 tests * 5 orders = 15 items.""" + d = self._data + all_items = [] + url = (PREFIX + f"/query?machine={d['machine']}" + "&metric=execution_time&limit=4") + + resp = self.client.get(url) + self.assertEqual(resp.status_code, 200, resp.get_json()) + data = resp.get_json() + all_items.extend(data['items']) + cursor = data['cursor']['next'] + + pages = 1 + while cursor: + resp = self.client.get(url + f'&cursor={cursor}') + self.assertEqual(resp.status_code, 200, resp.get_json()) + data = resp.get_json() + all_items.extend(data['items']) + cursor = data['cursor']['next'] + pages += 1 + if pages > 20: + self.fail("Too many pages; infinite loop detected") + + expected = len(d['test_names']) * d['num_orders'] + self.assertEqual(len(all_items), expected) + + def test_no_duplicates_across_pages(self): + d = self._data + all_keys = [] + url = (PREFIX + f"/query?machine={d['machine']}" + "&metric=execution_time&limit=4") + + resp = self.client.get(url) + data = resp.get_json() + all_keys.extend( + (item['test'], item['order']['llvm_project_revision']) + for item in data['items']) + cursor = data['cursor']['next'] + + pages = 1 + while cursor: + resp = self.client.get(url + f'&cursor={cursor}') + data = resp.get_json() + all_keys.extend( + (item['test'], item['order']['llvm_project_revision']) + for item in data['items']) + cursor = data['cursor']['next'] + pages += 1 + if pages > 20: + break + + self.assertEqual(len(all_keys), len(set(all_keys))) + + +class TestQuerySort(unittest.TestCase): + """Tests for the sort parameter.""" + + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + unique = uuid.uuid4().hex[:8] + cls._data = _setup_multi_test_data( + cls.app, + machine_name=f'query-sort-m-{unique}', + test_names=[f'query-sort-a/{unique}', + f'query-sort-b/{unique}', + f'query-sort-c/{unique}'], + num_orders=3, + ) + + def test_sort_by_test_order(self): + """sort=test,order groups results by test name.""" + d = self._data + resp = self.client.get( + PREFIX + f"/query?machine={d['machine']}" + "&metric=execution_time&sort=test,order") + data = resp.get_json() + test_names = [item['test'] for item in data['items']] + self.assertEqual(test_names, sorted(test_names)) + + def test_sort_by_order_test(self): + """sort=order,test is the default ordering.""" + d = self._data + resp = self.client.get( + PREFIX + f"/query?machine={d['machine']}" + "&metric=execution_time&sort=order,test") + data = resp.get_json() + # Items should be grouped by order + self.assertGreater(len(data['items']), 0) + + def test_sort_descending(self): + """-order,test returns newest orders first.""" + d = self._data + resp = self.client.get( + PREFIX + f"/query?machine={d['machine']}" + f"&test={d['test_names'][0]}" + "&metric=execution_time&sort=-order") + data = resp.get_json() + revisions = [ + item['order']['llvm_project_revision'] + for item in data['items'] + ] + self.assertEqual(revisions, sorted(revisions, reverse=True)) + + def test_sort_invalid_field_returns_400(self): + resp = self.client.get( + PREFIX + '/query?metric=execution_time&sort=invalid_field') + self.assertEqual(resp.status_code, 400) + + def test_sort_with_pagination(self): + """Sort order is preserved across cursor pages.""" + d = self._data + all_test_names = [] + url = (PREFIX + f"/query?machine={d['machine']}" + "&metric=execution_time&sort=test,order&limit=4") + + resp = self.client.get(url) + data = resp.get_json() + all_test_names.extend(item['test'] for item in data['items']) + cursor = data['cursor']['next'] + + pages = 1 + while cursor: + resp = self.client.get(url + f'&cursor={cursor}') + data = resp.get_json() + all_test_names.extend(item['test'] for item in data['items']) + cursor = data['cursor']['next'] + pages += 1 + if pages > 20: + break + + self.assertEqual(all_test_names, sorted(all_test_names)) + + +class TestQueryCursorMixedAscDesc(unittest.TestCase): + """Test cursor pagination with mixed ascending/descending sort.""" + + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + unique = uuid.uuid4().hex[:8] + cls._data = _setup_multi_test_data( + cls.app, + machine_name=f'query-mixed-m-{unique}', + test_names=[f'query-mixed-a/{unique}', + f'query-mixed-b/{unique}'], + num_orders=5, + ) + + def test_desc_order_pagination_collects_all(self): + """Paginating with -order,test collects all items.""" + d = self._data + all_items = [] + url = (PREFIX + f"/query?machine={d['machine']}" + "&metric=execution_time&sort=-order,test&limit=3") + resp = self.client.get(url) + self.assertEqual(resp.status_code, 200, resp.get_json()) + data = resp.get_json() + all_items.extend(data['items']) + cursor = data['cursor']['next'] + pages = 1 + while cursor: + resp = self.client.get(url + f'&cursor={cursor}') + self.assertEqual(resp.status_code, 200, resp.get_json()) + data = resp.get_json() + all_items.extend(data['items']) + cursor = data['cursor']['next'] + pages += 1 + if pages > 20: + self.fail("Too many pages") + expected = len(d['test_names']) * d['num_orders'] + self.assertEqual(len(all_items), expected) + + def test_desc_order_pagination_no_duplicates(self): + """No duplicates across pages with -order,test.""" + d = self._data + all_keys = [] + url = (PREFIX + f"/query?machine={d['machine']}" + "&metric=execution_time&sort=-order,test&limit=3") + resp = self.client.get(url) + data = resp.get_json() + all_keys.extend( + (item['test'], item['order']['llvm_project_revision']) + for item in data['items']) + cursor = data['cursor']['next'] + pages = 1 + while cursor: + resp = self.client.get(url + f'&cursor={cursor}') + data = resp.get_json() + all_keys.extend( + (item['test'], item['order']['llvm_project_revision']) + for item in data['items']) + cursor = data['cursor']['next'] + pages += 1 + if pages > 20: + break + self.assertEqual(len(all_keys), len(set(all_keys))) + + def test_desc_order_is_actually_descending(self): + """Results with -order are in descending order.""" + d = self._data + resp = self.client.get( + PREFIX + f"/query?machine={d['machine']}" + f"&test={d['test_names'][0]}" + "&metric=execution_time&sort=-order") + data = resp.get_json() + revisions = [ + int(item['order']['llvm_project_revision']) + for item in data['items'] + ] + self.assertEqual(revisions, sorted(revisions, reverse=True)) + + +class TestQueryMalformedTimestamp(unittest.TestCase): + """Test error handling for malformed timestamp filters.""" + + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_malformed_after_time_returns_400(self): + resp = self.client.get( + PREFIX + '/query?metric=execution_time&after_time=not-a-date') + self.assertEqual(resp.status_code, 400) + data = resp.get_json() + self.assertIn('error', data) + + def test_malformed_before_time_returns_400(self): + resp = self.client.get( + PREFIX + '/query?metric=execution_time&before_time=yesterday') + self.assertEqual(resp.status_code, 400) + data = resp.get_json() + self.assertIn('error', data) + + +class TestQueryMetricRequired(unittest.TestCase): + """Test that omitting the metric parameter returns 422.""" + + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + unique = uuid.uuid4().hex[:8] + mname = f'query-mreq-m-{unique}' + tname = f'query-mreq-t/{unique}' + db = cls.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + machine = create_machine(session, ts, name=mname) + test = create_test(session, ts, name=tname) + for i in range(3): + order = create_order(session, ts, revision=str(2000 + i)) + run = create_run(session, ts, machine, order, + start_time=datetime.datetime(2024, 6, 1 + i, 12, 0, 0)) + create_sample(session, ts, run, test, + execution_time=float(i + 1)) + session.commit() + session.close() + cls._data = {'machine': mname, 'test': tname} + + def test_omitting_metric_returns_422(self): + """Omitting the metric parameter should return 422.""" + d = self._data + url = (PREFIX + f"/query?machine={d['machine']}" + f"&test={d['test']}&limit=2") + resp = self.client.get(url) + self.assertEqual(resp.status_code, 422) + + def test_with_metric_returns_200(self): + """Providing metric should return 200 with data.""" + d = self._data + url = (PREFIX + f"/query?machine={d['machine']}" + f"&test={d['test']}&metric=execution_time&limit=2") + resp = self.client.get(url) + self.assertEqual(resp.status_code, 200, resp.get_json()) + data = resp.get_json() + self.assertGreater(len(data['items']), 0) + + +class TestQueryOrderRangeBoundaries(unittest.TestCase): + """Test boundary conditions for order range filters.""" + + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + unique = uuid.uuid4().hex[:8] + mname = f'query-orb-m-{unique}' + tname = f'query-orb-t/{unique}' + db = cls.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + machine = create_machine(session, ts, name=mname) + test = create_test(session, ts, name=tname) + for i in range(5): + rev = str(3000 + i * 10) # 3000, 3010, 3020, 3030, 3040 + order = create_order(session, ts, revision=rev) + run = create_run(session, ts, machine, order, + start_time=datetime.datetime(2024, 7, 1 + i, 12, 0, 0)) + create_sample(session, ts, run, test, execution_time=float(rev)) + session.commit() + session.close() + cls._data = {'machine': mname, 'test': tname} + + def test_same_after_and_before_order_returns_empty(self): + d = self._data + url = (PREFIX + f"/query?machine={d['machine']}&test={d['test']}" + "&metric=execution_time&after_order=3020&before_order=3020") + resp = self.client.get(url) + self.assertEqual(resp.status_code, 200, resp.get_json()) + data = resp.get_json() + self.assertEqual(len(data['items']), 0) + + def test_inverted_order_range_returns_empty(self): + d = self._data + url = (PREFIX + f"/query?machine={d['machine']}&test={d['test']}" + "&metric=execution_time&after_order=3040&before_order=3000") + resp = self.client.get(url) + self.assertEqual(resp.status_code, 200, resp.get_json()) + data = resp.get_json() + self.assertEqual(len(data['items']), 0) + + +class TestQueryLimitBoundaries(unittest.TestCase): + """Test boundary conditions for the limit parameter.""" + + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + unique = uuid.uuid4().hex[:8] + cls._data = _setup_query_data( + cls.app, + machine_name=f'query-limb-m-{unique}', + test_name=f'query-limb-t/{unique}', + num_points=5, + ) + + def test_limit_one_returns_one_item(self): + d = self._data + resp = self.client.get( + PREFIX + f"/query?machine={d['machine']}&test={d['test']}" + "&metric=execution_time&limit=1") + data = resp.get_json() + self.assertEqual(len(data['items']), 1) + self.assertIsNotNone(data['cursor']['next']) + + def test_limit_exceeding_max_is_clamped(self): + d = self._data + resp = self.client.get( + PREFIX + f"/query?machine={d['machine']}&test={d['test']}" + "&metric=execution_time&limit=99999") + self.assertEqual(resp.status_code, 200) + # Should not error; returns all 5 items (clamped limit > data size) + data = resp.get_json() + self.assertEqual(len(data['items']), d['num_points']) + + def test_limit_non_integer_uses_default(self): + d = self._data + resp = self.client.get( + PREFIX + f"/query?machine={d['machine']}&test={d['test']}" + "&metric=execution_time&limit=abc") + # Marshmallow validates limit as Integer; non-integer values -> 422 + self.assertEqual(resp.status_code, 422) + + def test_limit_zero_is_clamped_to_one(self): + d = self._data + resp = self.client.get( + PREFIX + f"/query?machine={d['machine']}&test={d['test']}" + "&metric=execution_time&limit=0") + data = resp.get_json() + self.assertEqual(len(data['items']), 1) + + +class TestQueryCursorEdgeCases(unittest.TestCase): + """Test cursor edge cases.""" + + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + unique = uuid.uuid4().hex[:8] + cls._data = _setup_query_data( + cls.app, + machine_name=f'query-cec-m-{unique}', + test_name=f'query-cec-t/{unique}', + num_points=3, + ) + + def test_cursor_wrong_field_count_returns_400(self): + """Cursor with wrong number of fields should be rejected.""" + import base64 + import json + # Default sort is order,test -> 2 fields. Encode 3 fields. + bad_cursor = base64.urlsafe_b64encode( + json.dumps([1, "x", "extra"]).encode()).decode() + d = self._data + resp = self.client.get( + PREFIX + f"/query?machine={d['machine']}&test={d['test']}" + f"&metric=execution_time&cursor={bad_cursor}") + self.assertEqual(resp.status_code, 400) + + def test_cursor_from_different_sort_order_is_rejected(self): + """Cursor from sort=order,test used with sort=test,order should fail + gracefully since the cursor values don't match the sort columns.""" + d = self._data + # Get cursor from sort=order,test (default) + resp = self.client.get( + PREFIX + f"/query?machine={d['machine']}&test={d['test']}" + "&metric=execution_time&limit=1") + cursor = resp.get_json()['cursor']['next'] + # Use with sort=test,order — mismatched cursor + resp2 = self.client.get( + PREFIX + f"/query?machine={d['machine']}&test={d['test']}" + f"&metric=execution_time&sort=test,order&cursor={cursor}") + self.assertEqual(resp2.status_code, 400) + + +class TestQuerySortValidation(unittest.TestCase): + """Test sort parameter validation edge cases.""" + + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_sort_duplicate_field_is_deduplicated(self): + resp = self.client.get( + PREFIX + '/query?metric=execution_time&sort=order,order,test') + self.assertEqual(resp.status_code, 200) + + def test_sort_empty_string_uses_default(self): + resp = self.client.get(PREFIX + '/query?metric=execution_time&sort=') + # Empty sort string should use default (order,test) + self.assertEqual(resp.status_code, 200) + + def test_sort_dash_invalid_field_returns_400(self): + resp = self.client.get(PREFIX + '/query?metric=execution_time&sort=-bogus') + self.assertEqual(resp.status_code, 400) + + +class TestQueryErrorResponseFormat(unittest.TestCase): + """Test that all error responses use the standard JSON format.""" + + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def _assert_error_format(self, resp): + """Assert the response body has the standard error format.""" + data = resp.get_json() + self.assertIsNotNone(data, "Response body should be JSON") + self.assertIn('error', data) + self.assertIn('code', data['error']) + self.assertIn('message', data['error']) + + def test_404_nonexistent_machine_has_error_format(self): + resp = self.client.get( + PREFIX + '/query?machine=nonexistent-xyz&metric=execution_time') + self.assertEqual(resp.status_code, 404) + self._assert_error_format(resp) + + def test_404_nonexistent_test_has_error_format(self): + resp = self.client.get( + PREFIX + '/query?test=nonexistent-xyz&metric=execution_time') + self.assertEqual(resp.status_code, 404) + self._assert_error_format(resp) + + def test_400_nonexistent_field_has_error_format(self): + resp = self.client.get( + PREFIX + '/query?metric=nonexistent_xyz') + self.assertEqual(resp.status_code, 400) + self._assert_error_format(resp) + + def test_400_invalid_sort_has_error_format(self): + resp = self.client.get( + PREFIX + '/query?metric=execution_time&sort=invalid') + self.assertEqual(resp.status_code, 400) + self._assert_error_format(resp) + + def test_400_invalid_cursor_has_error_format(self): + resp = self.client.get( + PREFIX + '/query?metric=execution_time&cursor=!!!invalid!!!') + self.assertEqual(resp.status_code, 400) + self._assert_error_format(resp) + + def test_400_malformed_time_has_error_format(self): + resp = self.client.get( + PREFIX + '/query?metric=execution_time&after_time=not-a-date') + self.assertEqual(resp.status_code, 400) + self._assert_error_format(resp) + + +class TestQueryNoInternalFieldsLeak(unittest.TestCase): + """Test that no internal fields (like _order_id) leak in response.""" + + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + unique = uuid.uuid4().hex[:8] + cls._data = _setup_query_data( + cls.app, + machine_name=f'query-noleak-m-{unique}', + test_name=f'query-noleak-t/{unique}', + num_points=3, + ) + + def test_no_underscore_prefixed_fields(self): + d = self._data + resp = self.client.get( + PREFIX + f"/query?machine={d['machine']}&test={d['test']}" + "&metric=execution_time") + data = resp.get_json() + for item in data['items']: + internal_keys = [k for k in item.keys() if k.startswith('_')] + self.assertEqual(internal_keys, [], + f"Internal fields leaked: {internal_keys}") + + +class TestQueryUnknownParameters(unittest.TestCase): + """Test that unknown query parameters are rejected with 400.""" + + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + unique = uuid.uuid4().hex[:8] + cls._data = _setup_query_data( + cls.app, + machine_name=f'query-unknown-m-{unique}', + test_name=f'query-unknown-t/{unique}', + num_points=3, + ) + + def test_single_unknown_param_returns_400(self): + """A single unknown parameter should be rejected.""" + resp = self.client.get(PREFIX + '/query?metric=execution_time&bogus=value') + self.assertEqual(resp.status_code, 400) + data = resp.get_json() + self.assertIn('error', data) + self.assertIn('bogus', data['error']['message']) + + def test_multiple_unknown_params_returns_400(self): + """Multiple unknown parameters should all be mentioned.""" + resp = self.client.get( + PREFIX + '/query?metric=execution_time' + '&metric_name=execution_time' + '&after_timestamp=2027-02-23T15:01:11') + self.assertEqual(resp.status_code, 400) + data = resp.get_json() + self.assertIn('metric_name', data['error']['message']) + self.assertIn('after_timestamp', data['error']['message']) + + def test_unknown_mixed_with_valid_returns_400(self): + """Unknown params mixed with valid ones should still be rejected.""" + d = self._data + resp = self.client.get( + PREFIX + f"/query?machine={d['machine']}" + "&metric=execution_time&bad_param=1") + self.assertEqual(resp.status_code, 400) + data = resp.get_json() + self.assertIn('bad_param', data['error']['message']) + + def test_error_message_lists_valid_params(self): + """The error message should list valid parameter names.""" + resp = self.client.get(PREFIX + '/query?metric=execution_time&bogus=1') + data = resp.get_json() + msg = data['error']['message'] + # Should mention the valid parameters + for valid in ('machine', 'test', 'metric', 'after_order', + 'before_order', 'after_time', 'before_time', + 'sort', 'limit', 'cursor'): + self.assertIn(valid, msg) + + def test_error_response_has_standard_format(self): + """Unknown param error should use the standard error format.""" + resp = self.client.get(PREFIX + '/query?metric=execution_time&unknown=1') + self.assertEqual(resp.status_code, 400) + data = resp.get_json() + self.assertIn('error', data) + self.assertIn('code', data['error']) + self.assertIn('message', data['error']) + self.assertEqual(data['error']['code'], 'validation_error') + + def test_valid_params_still_work(self): + """All valid parameters should still be accepted.""" + d = self._data + resp = self.client.get( + PREFIX + f"/query?machine={d['machine']}" + f"&test={d['test']}&metric=execution_time" + "&sort=order&limit=10") + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertIn('items', data) + self.assertEqual(len(data['items']), d['num_points']) + + def test_no_params_returns_422(self): + """Query with no parameters should return 422 (metric is required).""" + resp = self.client.get(PREFIX + '/query') + self.assertEqual(resp.status_code, 422) + + +if __name__ == '__main__': + unittest.main(argv=[sys.argv[0]], exit=True) diff --git a/tests/server/api/v5/test_regression_state_mapping.py b/tests/server/api/v5/test_regression_state_mapping.py new file mode 100644 index 000000000..e1b2d9472 --- /dev/null +++ b/tests/server/api/v5/test_regression_state_mapping.py @@ -0,0 +1,69 @@ +# Unit tests for the regression state mapping helpers (state_to_api / state_to_db). +# These are pure-function tests that do not require a database. +# +# RUN: python %s +# END. + +import sys +import unittest + +# Ensure the project root is importable. +import os +sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', '..', '..')) + +from lnt.server.api.v5.schemas.regressions import ( + STATE_TO_DB, + state_to_api, + state_to_db, +) + + +class TestStateToApi(unittest.TestCase): + """Tests for state_to_api().""" + + def test_all_known_states_round_trip(self): + """Every known DB integer maps to its expected API string.""" + for api_string, db_int in STATE_TO_DB.items(): + with self.subTest(db_int=db_int, expected=api_string): + self.assertEqual(state_to_api(db_int), api_string) + + def test_unknown_int_returns_unknown_prefix(self): + """An unmapped integer returns 'unknown_' instead of 'detected'.""" + result = state_to_api(999) + self.assertEqual(result, 'unknown_999') + + def test_unknown_negative_int(self): + result = state_to_api(-1) + self.assertEqual(result, 'unknown_-1') + + def test_unknown_none_value(self): + """None is not a valid DB state and should be flagged.""" + result = state_to_api(None) + self.assertEqual(result, 'unknown_None') + + def test_unknown_state_logs_warning(self): + """A warning should be logged when an unknown state is encountered.""" + with self.assertLogs( + 'lnt.server.api.v5.schemas.regressions', level='WARNING' + ) as cm: + state_to_api(999) + self.assertTrue( + any('999' in msg for msg in cm.output), + f"Expected '999' in log output, got: {cm.output}", + ) + + +class TestStateToDb(unittest.TestCase): + """Tests for state_to_db().""" + + def test_all_known_strings_round_trip(self): + for api_string, db_int in STATE_TO_DB.items(): + with self.subTest(api_string=api_string, expected=db_int): + self.assertEqual(state_to_db(api_string), db_int) + + def test_unknown_string_returns_none(self): + self.assertIsNone(state_to_db('bogus_state')) + + +if __name__ == '__main__': + unittest.main(argv=[sys.argv[0]], exit=True) diff --git a/tests/server/api/v5/test_regressions.py b/tests/server/api/v5/test_regressions.py new file mode 100644 index 000000000..a40345801 --- /dev/null +++ b/tests/server/api/v5/test_regressions.py @@ -0,0 +1,1123 @@ +# Tests for the v5 regression endpoints. +# +# RUN: rm -rf %t.instance %t.pg.log +# RUN: %{utils}/with_postgres.sh %t.pg.log \ +# RUN: %{utils}/with_temporary_instance.py %t.instance \ +# RUN: -- python %s %t.instance +# END. + +import sys +import os +import unittest +import uuid + +sys.path.insert(0, os.path.dirname(__file__)) +from v5_test_helpers import ( + admin_headers, create_app, create_client, make_scoped_headers, + collect_all_pages, +) + + +TS = 'nts' +PREFIX = f'/api/v5/{TS}' + + +def _triage_headers(app): + return make_scoped_headers(app, 'triage') + + +def _setup_fieldchange(client, app): + """Create a field change via the API and return its UUID.""" + tag = uuid.uuid4().hex[:8] + machine = f'reg-m-{tag}' + rev1 = f'reg-o1-{tag}' + rev2 = f'reg-o2-{tag}' + test = f'reg/test/{tag}' + _submit_run(client, machine, rev1, + [{'name': test, 'execution_time': [1.0]}]) + _submit_run(client, machine, rev2, + [{'name': test, 'execution_time': [2.0]}]) + fc = _create_fc(client, app, machine, test, + 'execution_time', rev1, rev2) + return fc['uuid'] + + +def _setup_regression_with_indicators(client, app, num_indicators=2): + """Create a regression with field changes via the API. + + Returns (regression_uuid, [fc_uuid, ...]). + """ + tag = uuid.uuid4().hex[:8] + machine = f'reg-m-{tag}' + rev1 = f'reg-o1-{tag}' + rev2 = f'reg-o2-{tag}' + tests = [ + {'name': f'reg/test/{tag}/{i}', 'execution_time': [1.0 + i]} + for i in range(num_indicators) + ] + _submit_run(client, machine, rev1, tests) + _submit_run(client, machine, rev2, [ + {'name': f'reg/test/{tag}/{i}', 'execution_time': [2.0 + i]} + for i in range(num_indicators) + ]) + fc_uuids = [] + for i in range(num_indicators): + fc = _create_fc(client, app, machine, f'reg/test/{tag}/{i}', + 'execution_time', rev1, rev2) + fc_uuids.append(fc['uuid']) + reg = _create_api_regression(client, app, fc_uuids) + return reg['uuid'], fc_uuids + + +def _submit_run(client, machine_name, revision, tests): + """Submit a run via the API. Returns the response JSON.""" + payload = { + 'format_version': '2', + 'machine': {'name': machine_name}, + 'run': { + 'start_time': '2024-06-15T10:00:00', + 'end_time': '2024-06-15T10:30:00', + 'llvm_project_revision': revision, + }, + 'tests': tests, + } + resp = client.post(PREFIX + '/runs', json=payload, + headers=admin_headers()) + return resp.get_json() + + +def _create_fc(client, app, machine, test, metric, start_rev, end_rev): + """Create a field change via the API. Returns the response JSON.""" + body = { + 'machine': machine, 'test': test, 'metric': metric, + 'old_value': 10.0, 'new_value': 20.0, + 'start_order': start_rev, 'end_order': end_rev, + } + headers = make_scoped_headers(app, 'submit') + resp = client.post(PREFIX + '/field-changes', + json=body, headers=headers) + return resp.get_json() + + +def _create_api_regression(client, app, fc_uuids, state='active'): + """Create a regression via the API. Returns the response JSON.""" + headers = make_scoped_headers(app, 'triage') + body = {'field_change_uuids': fc_uuids, 'state': state} + resp = client.post(PREFIX + '/regressions', + json=body, headers=headers) + return resp.get_json() + + +# ========================================================================== +# Regression List Tests +# ========================================================================== + +class TestRegressionList(unittest.TestCase): + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_list_returns_200_with_envelope(self): + resp = self.client.get(PREFIX + '/regressions') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertIn('items', data) + self.assertIsInstance(data['items'], list) + self.assertIn('cursor', data) + self.assertIn('next', data['cursor']) + self.assertIn('previous', data['cursor']) + + def test_list_item_has_expected_fields(self): + reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) + resp = self.client.get(PREFIX + '/regressions') + data = resp.get_json() + item = None + for r in data['items']: + if r['uuid'] == reg_uuid: + item = r + break + self.assertIsNotNone(item) + self.assertIn('uuid', item) + self.assertIn('title', item) + self.assertIn('bug', item) + self.assertIn('state', item) + # List items should NOT have indicators embedded + self.assertNotIn('indicators', item) + + def test_list_filter_by_state(self): + reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) + resp = self.client.get(PREFIX + '/regressions?state=active') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + for r in data['items']: + self.assertEqual(r['state'], 'active') + + def test_list_filter_by_state_multiple(self): + tag = uuid.uuid4().hex[:8] + machine = f'state-m-{tag}' + rev1 = f'state-o1-{tag}' + rev2 = f'state-o2-{tag}' + test1 = f'state-test/{tag}/1' + test2 = f'state-test/{tag}/2' + + _submit_run(self.client, machine, rev1, [ + {'name': test1, 'execution_time': [1.0]}, + {'name': test2, 'execution_time': [1.0]}, + ]) + _submit_run(self.client, machine, rev2, [ + {'name': test1, 'execution_time': [2.0]}, + {'name': test2, 'execution_time': [2.0]}, + ]) + + fc1 = _create_fc(self.client, self.app, machine, test1, + 'execution_time', rev1, rev2) + fc2 = _create_fc(self.client, self.app, machine, test2, + 'execution_time', rev1, rev2) + _create_api_regression(self.client, self.app, [fc1['uuid']], + state='active') + _create_api_regression(self.client, self.app, [fc2['uuid']], + state='detected') + + resp = self.client.get( + PREFIX + '/regressions?state=active,detected') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + states = {r['state'] for r in data['items']} + self.assertTrue(states.issubset({'active', 'detected'})) + + def test_list_filter_invalid_state_400(self): + resp = self.client.get(PREFIX + '/regressions?state=invalid_state') + self.assertEqual(resp.status_code, 400) + + def test_invalid_cursor_returns_400(self): + """An invalid cursor string should return 400.""" + resp = self.client.get( + PREFIX + '/regressions?cursor=not-a-valid-cursor!!!') + self.assertEqual(resp.status_code, 400) + + def test_list_pagination(self): + # Create 3 regressions + for _ in range(3): + _setup_regression_with_indicators(self.client, self.app, 1) + resp = self.client.get(PREFIX + '/regressions?limit=2') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertLessEqual(len(data['items']), 2) + if data['cursor']['next']: + cursor = data['cursor']['next'] + resp2 = self.client.get( + PREFIX + f'/regressions?limit=2&cursor={cursor}') + self.assertEqual(resp2.status_code, 200) + + +# ========================================================================== +# Regression List Filter Tests +# ========================================================================== + +class TestRegressionListFilters(unittest.TestCase): + """Tests for machine, test, and metric query filters on the list endpoint.""" + + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def _collect_filtered(self, query_string): + """Collect all regression UUIDs across pages for a filtered query.""" + url = PREFIX + '/regressions?' + query_string + '&limit=2' + items = collect_all_pages(self, self.client, url, page_limit=100) + return [r['uuid'] for r in items] + + def test_list_filter_by_machine(self): + """Filter by machine name returns only regressions on that machine.""" + tag = uuid.uuid4().hex[:8] + machine_name = f'filter-m-{tag}' + rev1 = f'filter-r1-{tag}' + rev2 = f'filter-r2-{tag}' + test_name = f'filter/test/{tag}' + + _submit_run(self.client, machine_name, rev1, + [{'name': test_name, 'execution_time': [1.0]}]) + _submit_run(self.client, machine_name, rev2, + [{'name': test_name, 'execution_time': [2.0]}]) + + fc = _create_fc(self.client, self.app, machine_name, test_name, + 'execution_time', rev1, rev2) + reg = _create_api_regression(self.client, self.app, [fc['uuid']]) + + uuids = self._collect_filtered(f'machine={machine_name}') + self.assertIn(reg['uuid'], uuids) + + def test_list_filter_by_test(self): + """Filter by test name returns only regressions on that test.""" + tag = uuid.uuid4().hex[:8] + machine_name = f'filter-tm-{tag}' + rev1 = f'filter-tr1-{tag}' + rev2 = f'filter-tr2-{tag}' + test_name = f'filter/testname/{tag}' + + _submit_run(self.client, machine_name, rev1, + [{'name': test_name, 'execution_time': [1.0]}]) + _submit_run(self.client, machine_name, rev2, + [{'name': test_name, 'execution_time': [2.0]}]) + + fc = _create_fc(self.client, self.app, machine_name, test_name, + 'execution_time', rev1, rev2) + reg = _create_api_regression(self.client, self.app, [fc['uuid']]) + + uuids = self._collect_filtered(f'test={test_name}') + self.assertIn(reg['uuid'], uuids) + + def test_list_filter_by_metric(self): + """Filter by metric returns only regressions with that metric.""" + tag = uuid.uuid4().hex[:8] + machine_name = f'filter-mm-{tag}' + rev1 = f'filter-mr1-{tag}' + rev2 = f'filter-mr2-{tag}' + test_ct = f'filter/compile/{tag}' + test_et = f'filter/exec/{tag}' + + # Submit runs with both metrics + _submit_run(self.client, machine_name, rev1, [ + {'name': test_ct, 'compile_time': [5.0]}, + {'name': test_et, 'execution_time': [1.0]}, + ]) + _submit_run(self.client, machine_name, rev2, [ + {'name': test_ct, 'compile_time': [10.0]}, + {'name': test_et, 'execution_time': [2.0]}, + ]) + + # Create field change + regression for compile_time + fc_ct = _create_fc(self.client, self.app, machine_name, test_ct, + 'compile_time', rev1, rev2) + reg_ct = _create_api_regression(self.client, self.app, + [fc_ct['uuid']]) + + # Create field change + regression for execution_time + fc_et = _create_fc(self.client, self.app, machine_name, test_et, + 'execution_time', rev1, rev2) + reg_et = _create_api_regression(self.client, self.app, + [fc_et['uuid']]) + + # Filter by execution_time -- should include reg_et, exclude reg_ct + uuids = self._collect_filtered('metric=execution_time') + self.assertIn(reg_et['uuid'], uuids) + self.assertNotIn(reg_ct['uuid'], uuids) + + def test_list_filter_by_metric_unknown_returns_400(self): + """Filtering by a nonexistent metric returns 400.""" + resp = self.client.get( + PREFIX + '/regressions?metric=nonexistent_metric') + self.assertEqual(resp.status_code, 400) + + def test_list_filter_combined(self): + """Combined machine + test + metric filter narrows results.""" + tag = uuid.uuid4().hex[:8] + machine_name = f'filter-cm-{tag}' + rev1 = f'filter-cr1-{tag}' + rev2 = f'filter-cr2-{tag}' + test_name = f'filter/combined/{tag}' + + _submit_run(self.client, machine_name, rev1, + [{'name': test_name, 'execution_time': [1.0]}]) + _submit_run(self.client, machine_name, rev2, + [{'name': test_name, 'execution_time': [2.0]}]) + + fc = _create_fc(self.client, self.app, machine_name, test_name, + 'execution_time', rev1, rev2) + reg = _create_api_regression(self.client, self.app, [fc['uuid']]) + + uuids = self._collect_filtered( + f'machine={machine_name}&test={test_name}' + f'&metric=execution_time') + self.assertIn(reg['uuid'], uuids) + + +# ========================================================================== +# Regression Create Tests +# ========================================================================== + +class TestRegressionCreate(unittest.TestCase): + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_create_regression(self): + fc_uuid = _setup_fieldchange(self.client, self.app) + headers = _triage_headers(self.app) + resp = self.client.post( + PREFIX + '/regressions', + json={'field_change_uuids': [fc_uuid]}, + headers=headers, + ) + self.assertEqual(resp.status_code, 201) + data = resp.get_json() + self.assertIn('uuid', data) + self.assertIn('indicators', data) + self.assertEqual(len(data['indicators']), 1) + self.assertEqual(data['indicators'][0]['field_change_uuid'], fc_uuid) + + def test_create_with_custom_title(self): + fc_uuid = _setup_fieldchange(self.client, self.app) + headers = _triage_headers(self.app) + resp = self.client.post( + PREFIX + '/regressions', + json={ + 'field_change_uuids': [fc_uuid], + 'title': 'Custom Title', + }, + headers=headers, + ) + self.assertEqual(resp.status_code, 201) + data = resp.get_json() + self.assertEqual(data['title'], 'Custom Title') + + def test_create_with_state(self): + fc_uuid = _setup_fieldchange(self.client, self.app) + headers = _triage_headers(self.app) + resp = self.client.post( + PREFIX + '/regressions', + json={ + 'field_change_uuids': [fc_uuid], + 'state': 'active', + }, + headers=headers, + ) + self.assertEqual(resp.status_code, 201) + data = resp.get_json() + self.assertEqual(data['state'], 'active') + + def test_create_default_state_detected(self): + fc_uuid = _setup_fieldchange(self.client, self.app) + headers = _triage_headers(self.app) + resp = self.client.post( + PREFIX + '/regressions', + json={'field_change_uuids': [fc_uuid]}, + headers=headers, + ) + self.assertEqual(resp.status_code, 201) + data = resp.get_json() + self.assertEqual(data['state'], 'detected') + + def test_create_missing_field_changes_422(self): + headers = _triage_headers(self.app) + resp = self.client.post( + PREFIX + '/regressions', + json={}, + headers=headers, + ) + self.assertEqual(resp.status_code, 422) + + def test_create_empty_field_changes_422(self): + headers = _triage_headers(self.app) + resp = self.client.post( + PREFIX + '/regressions', + json={'field_change_uuids': []}, + headers=headers, + ) + self.assertEqual(resp.status_code, 422) + + def test_create_invalid_field_change_uuid_404(self): + headers = _triage_headers(self.app) + resp = self.client.post( + PREFIX + '/regressions', + json={'field_change_uuids': ['nonexistent-uuid']}, + headers=headers, + ) + self.assertEqual(resp.status_code, 404) + + def test_create_invalid_state_422(self): + fc_uuid = _setup_fieldchange(self.client, self.app) + headers = _triage_headers(self.app) + resp = self.client.post( + PREFIX + '/regressions', + json={ + 'field_change_uuids': [fc_uuid], + 'state': 'bogus_state', + }, + headers=headers, + ) + self.assertEqual(resp.status_code, 422) + + def test_create_no_auth_401(self): + resp = self.client.post( + PREFIX + '/regressions', + json={'field_change_uuids': ['x']}, + ) + self.assertEqual(resp.status_code, 401) + + def test_create_read_scope_403(self): + headers = make_scoped_headers(self.app, 'read') + resp = self.client.post( + PREFIX + '/regressions', + json={'field_change_uuids': ['x']}, + headers=headers, + ) + self.assertEqual(resp.status_code, 403) + + +# ========================================================================== +# Regression Detail Tests +# ========================================================================== + +class TestRegressionDetail(unittest.TestCase): + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_get_detail(self): + reg_uuid, fc_uuids = _setup_regression_with_indicators(self.client, self.app, 1) + resp = self.client.get(PREFIX + f'/regressions/{reg_uuid}') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertEqual(data['uuid'], reg_uuid) + self.assertIn('title', data) + self.assertIn('bug', data) + self.assertIn('state', data) + self.assertIn('indicators', data) + self.assertEqual(len(data['indicators']), 1) + ind = data['indicators'][0] + self.assertIn('field_change_uuid', ind) + self.assertIn('test', ind) + self.assertIn('machine', ind) + self.assertIn('metric', ind) + self.assertIn('old_value', ind) + self.assertIn('new_value', ind) + self.assertIn('start_order', ind) + self.assertIn('end_order', ind) + self.assertIn('run_uuid', ind) + + def test_detail_nonexistent_404(self): + resp = self.client.get( + PREFIX + '/regressions/nonexistent-uuid-12345') + self.assertEqual(resp.status_code, 404) + + def test_detail_state_is_string(self): + reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) + resp = self.client.get(PREFIX + f'/regressions/{reg_uuid}') + data = resp.get_json() + self.assertIsInstance(data['state'], str) + self.assertEqual(data['state'], 'active') # state=10 -> 'active' + + +class TestRegressionDetailETag(unittest.TestCase): + """ETag tests for GET /api/v5/{ts}/regressions/{uuid}.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_etag_present_on_detail(self): + """Regression detail response should include an ETag header.""" + reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) + resp = self.client.get(PREFIX + f'/regressions/{reg_uuid}') + self.assertEqual(resp.status_code, 200) + etag = resp.headers.get('ETag') + self.assertIsNotNone(etag) + self.assertTrue(etag.startswith('W/"')) + + def test_etag_304_on_match(self): + """Sending If-None-Match with the same ETag returns 304.""" + reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) + resp = self.client.get(PREFIX + f'/regressions/{reg_uuid}') + etag = resp.headers.get('ETag') + + resp2 = self.client.get( + PREFIX + f'/regressions/{reg_uuid}', + headers={'If-None-Match': etag}, + ) + self.assertEqual(resp2.status_code, 304) + + def test_etag_200_on_mismatch(self): + """Sending If-None-Match with a different ETag returns 200.""" + reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) + resp = self.client.get( + PREFIX + f'/regressions/{reg_uuid}', + headers={'If-None-Match': 'W/"stale-etag-value"'}, + ) + self.assertEqual(resp.status_code, 200) + self.assertIsNotNone(resp.get_json()) + + +# ========================================================================== +# Regression Update Tests +# ========================================================================== + +class TestRegressionUpdate(unittest.TestCase): + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_update_title(self): + reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) + headers = _triage_headers(self.app) + resp = self.client.patch( + PREFIX + f'/regressions/{reg_uuid}', + json={'title': 'Updated Title'}, + headers=headers, + ) + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertEqual(data['title'], 'Updated Title') + + def test_update_bug(self): + reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) + headers = _triage_headers(self.app) + resp = self.client.patch( + PREFIX + f'/regressions/{reg_uuid}', + json={'bug': 'https://bugs.example.com/123'}, + headers=headers, + ) + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertEqual(data['bug'], 'https://bugs.example.com/123') + + def test_update_state(self): + reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) + headers = _triage_headers(self.app) + resp = self.client.patch( + PREFIX + f'/regressions/{reg_uuid}', + json={'state': 'fixed'}, + headers=headers, + ) + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertEqual(data['state'], 'fixed') + + def test_update_state_any_transition(self): + """State transitions are unconstrained -- any -> any.""" + reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) + headers = _triage_headers(self.app) + # active -> ignored + resp = self.client.patch( + PREFIX + f'/regressions/{reg_uuid}', + json={'state': 'ignored'}, + headers=headers, + ) + self.assertEqual(resp.status_code, 200) + self.assertEqual(resp.get_json()['state'], 'ignored') + # ignored -> detected + resp = self.client.patch( + PREFIX + f'/regressions/{reg_uuid}', + json={'state': 'detected'}, + headers=headers, + ) + self.assertEqual(resp.status_code, 200) + self.assertEqual(resp.get_json()['state'], 'detected') + + def test_update_invalid_state_422(self): + reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) + headers = _triage_headers(self.app) + resp = self.client.patch( + PREFIX + f'/regressions/{reg_uuid}', + json={'state': 'not_a_real_state'}, + headers=headers, + ) + self.assertEqual(resp.status_code, 422) + + def test_update_nonexistent_404(self): + headers = _triage_headers(self.app) + resp = self.client.patch( + PREFIX + '/regressions/nonexistent-uuid', + json={'title': 'x'}, + headers=headers, + ) + self.assertEqual(resp.status_code, 404) + + def test_update_no_auth_401(self): + reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) + resp = self.client.patch( + PREFIX + f'/regressions/{reg_uuid}', + json={'title': 'x'}, + ) + self.assertEqual(resp.status_code, 401) + + def test_update_read_scope_403(self): + reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) + headers = make_scoped_headers(self.app, 'read') + resp = self.client.patch( + PREFIX + f'/regressions/{reg_uuid}', + json={'title': 'x'}, + headers=headers, + ) + self.assertEqual(resp.status_code, 403) + + def test_update_returns_indicators(self): + """PATCH response should include indicators.""" + reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 2) + headers = _triage_headers(self.app) + resp = self.client.patch( + PREFIX + f'/regressions/{reg_uuid}', + json={'title': 'With Indicators'}, + headers=headers, + ) + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertIn('indicators', data) + self.assertEqual(len(data['indicators']), 2) + + +# ========================================================================== +# Regression Delete Tests +# ========================================================================== + +class TestRegressionDelete(unittest.TestCase): + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_delete_regression(self): + reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) + headers = _triage_headers(self.app) + resp = self.client.delete( + PREFIX + f'/regressions/{reg_uuid}', + headers=headers, + ) + self.assertEqual(resp.status_code, 204) + + # Verify it's gone + resp = self.client.get(PREFIX + f'/regressions/{reg_uuid}') + self.assertEqual(resp.status_code, 404) + + def test_delete_nonexistent_404(self): + headers = _triage_headers(self.app) + resp = self.client.delete( + PREFIX + '/regressions/nonexistent-uuid', + headers=headers, + ) + self.assertEqual(resp.status_code, 404) + + def test_delete_no_auth_401(self): + reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) + resp = self.client.delete( + PREFIX + f'/regressions/{reg_uuid}', + ) + self.assertEqual(resp.status_code, 401) + + +# ========================================================================== +# Regression Merge Tests +# ========================================================================== + +class TestRegressionMerge(unittest.TestCase): + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_merge_regressions(self): + """Merge source into target: target gets all indicators.""" + target_uuid, target_fcs = _setup_regression_with_indicators( + self.client, self.app, 2) + source_uuid, source_fcs = _setup_regression_with_indicators( + self.client, self.app, 2) + headers = _triage_headers(self.app) + + resp = self.client.post( + PREFIX + f'/regressions/{target_uuid}/merge', + json={'source_regression_uuids': [source_uuid]}, + headers=headers, + ) + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + # Target should now have all 4 indicators + self.assertEqual(len(data['indicators']), 4) + + # Source should be marked as IGNORED + resp2 = self.client.get(PREFIX + f'/regressions/{source_uuid}') + self.assertEqual(resp2.status_code, 200) + self.assertEqual(resp2.get_json()['state'], 'ignored') + + def test_merge_deduplicates_indicators(self): + """If source has same field change as target, deduplicate.""" + tag = uuid.uuid4().hex[:8] + machine = f'dup-m-{tag}' + rev1 = f'dup-o1-{tag}' + rev2 = f'dup-o2-{tag}' + test1 = f'dup-test/{tag}' + test2 = f'dup-test2/{tag}' + + _submit_run(self.client, machine, rev1, [ + {'name': test1, 'execution_time': [1.0]}, + {'name': test2, 'execution_time': [1.0]}, + ]) + _submit_run(self.client, machine, rev2, [ + {'name': test1, 'execution_time': [2.0]}, + {'name': test2, 'execution_time': [2.0]}, + ]) + + shared_fc = _create_fc(self.client, self.app, machine, test1, + 'execution_time', rev1, rev2) + unique_fc = _create_fc(self.client, self.app, machine, test2, + 'execution_time', rev1, rev2) + + target = _create_api_regression( + self.client, self.app, + [shared_fc['uuid'], unique_fc['uuid']]) + source = _create_api_regression( + self.client, self.app, [shared_fc['uuid']]) + + target_uuid = target['uuid'] + source_uuid = source['uuid'] + + headers = _triage_headers(self.app) + resp = self.client.post( + PREFIX + f'/regressions/{target_uuid}/merge', + json={'source_regression_uuids': [source_uuid]}, + headers=headers, + ) + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertEqual(len(data['indicators']), 2) + + def test_merge_into_self_400(self): + reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) + headers = _triage_headers(self.app) + resp = self.client.post( + PREFIX + f'/regressions/{reg_uuid}/merge', + json={'source_regression_uuids': [reg_uuid]}, + headers=headers, + ) + self.assertEqual(resp.status_code, 400) + + def test_merge_missing_body_422(self): + reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) + headers = _triage_headers(self.app) + resp = self.client.post( + PREFIX + f'/regressions/{reg_uuid}/merge', + json={}, + headers=headers, + ) + self.assertEqual(resp.status_code, 422) + + def test_merge_nonexistent_source_404(self): + reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) + headers = _triage_headers(self.app) + resp = self.client.post( + PREFIX + f'/regressions/{reg_uuid}/merge', + json={'source_regression_uuids': ['nonexistent-uuid']}, + headers=headers, + ) + self.assertEqual(resp.status_code, 404) + + def test_merge_nonexistent_target_404(self): + headers = _triage_headers(self.app) + resp = self.client.post( + PREFIX + '/regressions/nonexistent-uuid/merge', + json={'source_regression_uuids': ['also-nonexistent']}, + headers=headers, + ) + self.assertEqual(resp.status_code, 404) + + def test_merge_no_auth_401(self): + reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) + resp = self.client.post( + PREFIX + f'/regressions/{reg_uuid}/merge', + json={'source_regression_uuids': ['x']}, + ) + self.assertEqual(resp.status_code, 401) + + +# ========================================================================== +# Regression Split Tests +# ========================================================================== + +class TestRegressionSplit(unittest.TestCase): + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_split_regression(self): + """Split one field change into a new regression.""" + reg_uuid, fc_uuids = _setup_regression_with_indicators(self.client, self.app, 3) + headers = _triage_headers(self.app) + + resp = self.client.post( + PREFIX + f'/regressions/{reg_uuid}/split', + json={'field_change_uuids': [fc_uuids[0]]}, + headers=headers, + ) + self.assertEqual(resp.status_code, 201) + data = resp.get_json() + self.assertIn('uuid', data) + self.assertNotEqual(data['uuid'], reg_uuid) + self.assertEqual(len(data['indicators']), 1) + self.assertEqual(data['indicators'][0]['field_change_uuid'], + fc_uuids[0]) + + # Original regression should have 2 remaining indicators + resp2 = self.client.get(PREFIX + f'/regressions/{reg_uuid}') + self.assertEqual(resp2.status_code, 200) + data2 = resp2.get_json() + self.assertEqual(len(data2['indicators']), 2) + + def test_split_all_indicators_400(self): + """Cannot split ALL indicators -- would leave source empty.""" + reg_uuid, fc_uuids = _setup_regression_with_indicators(self.client, self.app, 2) + headers = _triage_headers(self.app) + + resp = self.client.post( + PREFIX + f'/regressions/{reg_uuid}/split', + json={'field_change_uuids': fc_uuids}, + headers=headers, + ) + self.assertEqual(resp.status_code, 400) + + def test_split_missing_body_422(self): + reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 2) + headers = _triage_headers(self.app) + resp = self.client.post( + PREFIX + f'/regressions/{reg_uuid}/split', + json={}, + headers=headers, + ) + self.assertEqual(resp.status_code, 422) + + def test_split_fc_not_in_regression_400(self): + """Splitting a field change that's not in this regression -> 400.""" + reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 2) + other_fc_uuid = _setup_fieldchange(self.client, self.app) + headers = _triage_headers(self.app) + resp = self.client.post( + PREFIX + f'/regressions/{reg_uuid}/split', + json={'field_change_uuids': [other_fc_uuid]}, + headers=headers, + ) + self.assertEqual(resp.status_code, 400) + + def test_split_nonexistent_regression_404(self): + headers = _triage_headers(self.app) + resp = self.client.post( + PREFIX + '/regressions/nonexistent-uuid/split', + json={'field_change_uuids': ['x']}, + headers=headers, + ) + self.assertEqual(resp.status_code, 404) + + def test_split_no_auth_401(self): + reg_uuid, fc_uuids = _setup_regression_with_indicators(self.client, self.app, 2) + resp = self.client.post( + PREFIX + f'/regressions/{reg_uuid}/split', + json={'field_change_uuids': [fc_uuids[0]]}, + ) + self.assertEqual(resp.status_code, 401) + + +# ========================================================================== +# Regression Indicators Tests +# ========================================================================== + +class TestRegressionIndicators(unittest.TestCase): + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_list_indicators(self): + reg_uuid, fc_uuids = _setup_regression_with_indicators(self.client, self.app, 2) + resp = self.client.get( + PREFIX + f'/regressions/{reg_uuid}/indicators') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertIn('items', data) + self.assertEqual(len(data['items']), 2) + self.assertIn('cursor', data) + + def test_list_indicators_nonexistent_regression_404(self): + resp = self.client.get( + PREFIX + '/regressions/nonexistent-uuid/indicators') + self.assertEqual(resp.status_code, 404) + + def test_add_indicator(self): + reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) + fc_uuid = _setup_fieldchange(self.client, self.app) + headers = _triage_headers(self.app) + + resp = self.client.post( + PREFIX + f'/regressions/{reg_uuid}/indicators', + json={'field_change_uuid': fc_uuid}, + headers=headers, + ) + self.assertEqual(resp.status_code, 201) + data = resp.get_json() + self.assertEqual(data['field_change_uuid'], fc_uuid) + + # Verify it appears in the indicators list + resp2 = self.client.get( + PREFIX + f'/regressions/{reg_uuid}/indicators') + data2 = resp2.get_json() + self.assertEqual(len(data2['items']), 2) + + def test_add_duplicate_indicator_409(self): + reg_uuid, fc_uuids = _setup_regression_with_indicators(self.client, self.app, 1) + headers = _triage_headers(self.app) + resp = self.client.post( + PREFIX + f'/regressions/{reg_uuid}/indicators', + json={'field_change_uuid': fc_uuids[0]}, + headers=headers, + ) + self.assertEqual(resp.status_code, 409) + + def test_add_nonexistent_fc_404(self): + reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) + headers = _triage_headers(self.app) + resp = self.client.post( + PREFIX + f'/regressions/{reg_uuid}/indicators', + json={'field_change_uuid': 'nonexistent-uuid'}, + headers=headers, + ) + self.assertEqual(resp.status_code, 404) + + def test_add_indicator_no_auth_401(self): + reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) + resp = self.client.post( + PREFIX + f'/regressions/{reg_uuid}/indicators', + json={'field_change_uuid': 'x'}, + ) + self.assertEqual(resp.status_code, 401) + + def test_remove_indicator(self): + reg_uuid, fc_uuids = _setup_regression_with_indicators(self.client, self.app, 2) + headers = _triage_headers(self.app) + resp = self.client.delete( + PREFIX + f'/regressions/{reg_uuid}/indicators/{fc_uuids[0]}', + headers=headers, + ) + self.assertEqual(resp.status_code, 204) + + # Verify indicator is removed + resp2 = self.client.get( + PREFIX + f'/regressions/{reg_uuid}/indicators') + data2 = resp2.get_json() + self.assertEqual(len(data2['items']), 1) + + def test_remove_nonexistent_indicator_404(self): + reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) + headers = _triage_headers(self.app) + resp = self.client.delete( + PREFIX + f'/regressions/{reg_uuid}/indicators/nonexistent-fc-uuid', + headers=headers, + ) + self.assertEqual(resp.status_code, 404) + + def test_remove_indicator_not_linked_404(self): + """Remove a field change that exists but is not linked.""" + reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) + other_fc_uuid = _setup_fieldchange(self.client, self.app) + headers = _triage_headers(self.app) + resp = self.client.delete( + PREFIX + f'/regressions/{reg_uuid}/indicators/{other_fc_uuid}', + headers=headers, + ) + self.assertEqual(resp.status_code, 404) + + def test_invalid_cursor_returns_400(self): + """An invalid cursor string should return 400.""" + reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) + resp = self.client.get( + PREFIX + f'/regressions/{reg_uuid}/indicators' + '?cursor=not-a-valid-cursor!!!') + self.assertEqual(resp.status_code, 400) + + +class TestRegressionZPagination(unittest.TestCase): + """Exhaustive cursor pagination tests for GET /api/v5/{ts}/regressions.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + cls._reg_uuids = [] + for _ in range(5): + reg_uuid, _ = _setup_regression_with_indicators(cls.client, cls.app, 1) + cls._reg_uuids.append(reg_uuid) + + def _collect_all_pages(self): + url = PREFIX + '/regressions?limit=2' + return collect_all_pages(self, self.client, url, page_limit=100) + + def test_pagination_collects_all_items(self): + """Paginating through all pages collects all created regressions.""" + all_items = self._collect_all_pages() + collected_uuids = [item['uuid'] for item in all_items] + for reg_uuid in self._reg_uuids: + self.assertIn(reg_uuid, collected_uuids) + + def test_no_duplicate_items_across_pages(self): + """No duplicate regression UUIDs across pages.""" + all_items = self._collect_all_pages() + uuids = [item['uuid'] for item in all_items] + self.assertEqual(len(uuids), len(set(uuids))) + + +class TestRegressionZIndicatorPagination(unittest.TestCase): + """Exhaustive cursor pagination tests for GET /api/v5/{ts}/regressions/{uuid}/indicators.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + cls._reg_uuid, cls._fc_uuids = _setup_regression_with_indicators( + cls.client, cls.app, num_indicators=5) + + def _collect_all_pages(self): + url = PREFIX + f'/regressions/{self._reg_uuid}/indicators?limit=2' + return collect_all_pages(self, self.client, url) + + def test_pagination_collects_all_items(self): + """Paginating through all pages collects all 5 indicators.""" + all_items = self._collect_all_pages() + self.assertEqual(len(all_items), 5) + + def test_no_duplicate_items_across_pages(self): + """No duplicate field change UUIDs across pages.""" + all_items = self._collect_all_pages() + fc_uuids = [item['field_change_uuid'] for item in all_items] + self.assertEqual(len(fc_uuids), len(set(fc_uuids))) + + +class TestRegressionUnknownParams(unittest.TestCase): + """Test that unknown query parameters are rejected with 400.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_regressions_list_unknown_param_returns_400(self): + resp = self.client.get(PREFIX + '/regressions?bogus=1') + self.assertEqual(resp.status_code, 400) + data = resp.get_json() + self.assertIn('bogus', data['error']['message']) + + def test_regression_detail_unknown_param_returns_400(self): + reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) + resp = self.client.get( + PREFIX + f'/regressions/{reg_uuid}?bogus=1') + self.assertEqual(resp.status_code, 400) + + def test_regression_indicators_unknown_param_returns_400(self): + reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) + resp = self.client.get( + PREFIX + f'/regressions/{reg_uuid}/indicators?bogus=1') + self.assertEqual(resp.status_code, 400) + + +if __name__ == '__main__': + unittest.main(argv=[sys.argv[0]], exit=True) diff --git a/tests/server/api/v5/test_runs.py b/tests/server/api/v5/test_runs.py new file mode 100644 index 000000000..4080009ca --- /dev/null +++ b/tests/server/api/v5/test_runs.py @@ -0,0 +1,1242 @@ +# Tests for the v5 run endpoints. +# +# RUN: rm -rf %t.instance %t.pg.log +# RUN: %{utils}/with_postgres.sh %t.pg.log \ +# RUN: %{utils}/with_temporary_instance.py %t.instance \ +# RUN: -- python %s %t.instance +# END. + +import datetime +import json +import sys +import os +import unittest +import uuid + +sys.path.insert(0, os.path.dirname(__file__)) +from v5_test_helpers import ( + create_app, create_client, admin_headers, make_scoped_headers, + create_machine, create_order, create_run, collect_all_pages, +) + + +TS = 'nts' +PREFIX = f'/api/v5/{TS}' + + +def _make_submission_payload(machine_name=None, revision=None, + start_time=None, end_time=None): + """Build a valid v2-format JSON submission payload.""" + if machine_name is None: + machine_name = f'submit-machine-{uuid.uuid4().hex[:8]}' + if revision is None: + revision = f'r{uuid.uuid4().hex[:8]}' + if start_time is None: + start_time = '2024-06-15T10:00:00' + if end_time is None: + end_time = '2024-06-15T10:30:00' + + return json.dumps({ + 'format_version': '2', + 'machine': { + 'name': machine_name, + }, + 'run': { + 'start_time': start_time, + 'end_time': end_time, + 'llvm_project_revision': revision, + }, + 'tests': [ + { + 'name': 'test.suite/benchmark1', + 'execution_time': [0.1234, 0.1235], + }, + ], + }) + + +class TestRunListEmpty(unittest.TestCase): + """Tests for GET /api/v5/{ts}/runs with no data.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_list_returns_200(self): + resp = self.client.get(PREFIX + '/runs') + self.assertEqual(resp.status_code, 200) + + def test_list_has_items_key(self): + resp = self.client.get(PREFIX + '/runs') + data = resp.get_json() + self.assertIn('items', data) + self.assertIsInstance(data['items'], list) + + def test_list_has_pagination_envelope(self): + resp = self.client.get(PREFIX + '/runs') + data = resp.get_json() + self.assertIn('cursor', data) + self.assertIn('next', data['cursor']) + self.assertIn('previous', data['cursor']) + + +class TestRunListWithData(unittest.TestCase): + """Tests for GET /api/v5/{ts}/runs with existing data.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_list_includes_created_runs(self): + """Runs created via DB helpers appear in list.""" + name = f'list-data-{uuid.uuid4().hex[:8]}' + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + machine = create_machine(session, ts, name=name) + order = create_order(session, ts, revision=f'list-rev-{uuid.uuid4().hex[:6]}') + run = create_run(session, ts, machine, order) + run_uuid = run.uuid + session.commit() + session.close() + + resp = self.client.get(PREFIX + f'/runs?machine={name}') + data = resp.get_json() + uuids = [item['uuid'] for item in data['items']] + self.assertIn(run_uuid, uuids) + + def test_list_run_has_expected_fields(self): + """Each run in the list has uuid, machine_name, order, start_time, end_time.""" + name = f'list-fields-{uuid.uuid4().hex[:8]}' + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + machine = create_machine(session, ts, name=name) + order = create_order(session, ts, revision=f'fields-rev-{uuid.uuid4().hex[:6]}') + create_run(session, ts, machine, order) + session.commit() + session.close() + + resp = self.client.get(PREFIX + f'/runs?machine={name}') + data = resp.get_json() + self.assertGreater(len(data['items']), 0) + item = data['items'][0] + self.assertIn('uuid', item) + self.assertIn('machine', item) + self.assertIn('order', item) + self.assertIn('start_time', item) + self.assertIn('end_time', item) + # Must NOT have internal IDs + self.assertNotIn('id', item) + self.assertNotIn('machine_id', item) + + def test_list_never_exposes_internal_ids(self): + """Run list items never contain internal database IDs.""" + name = f'no-ids-{uuid.uuid4().hex[:8]}' + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + machine = create_machine(session, ts, name=name) + order = create_order(session, ts, revision=f'noid-rev-{uuid.uuid4().hex[:6]}') + create_run(session, ts, machine, order) + session.commit() + session.close() + + resp = self.client.get(PREFIX + f'/runs?machine={name}') + data = resp.get_json() + for item in data['items']: + self.assertNotIn('id', item) + self.assertNotIn('machine_id', item) + self.assertNotIn('order_id', item) + + +class TestRunListPagination(unittest.TestCase): + """Tests for run list pagination.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_pagination(self): + """Create multiple runs and paginate through them.""" + name = f'page-{uuid.uuid4().hex[:8]}' + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + machine = create_machine(session, ts, name=name) + for i in range(3): + order = create_order(session, ts, revision=f'page-rev-{uuid.uuid4().hex[:6]}-{i}') + create_run(session, ts, machine, order, + start_time=datetime.datetime(2024, 1, 1 + i, 12, 0, 0)) + session.commit() + session.close() + + # Get first page with limit=2 + resp = self.client.get(PREFIX + f'/runs?machine={name}&limit=2') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertEqual(len(data['items']), 2) + self.assertIsNotNone(data['cursor']['next']) + + # Follow cursor + cursor = data['cursor']['next'] + resp2 = self.client.get( + PREFIX + f'/runs?machine={name}&limit=2&cursor={cursor}') + self.assertEqual(resp2.status_code, 200) + data2 = resp2.get_json() + self.assertEqual(len(data2['items']), 1) + self.assertIsNone(data2['cursor']['next']) + + +class TestRunSubmit(unittest.TestCase): + """Tests for POST /api/v5/{ts}/runs (run submission).""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_submit_valid_payload(self): + """Submit a valid JSON payload and verify response.""" + payload = _make_submission_payload() + resp = self.client.post( + PREFIX + '/runs', + data=payload, + content_type='application/json', + headers=admin_headers(), + ) + # The import pipeline returns 201 on success + self.assertIn(resp.status_code, [201, 301]) + data = resp.get_json() + self.assertTrue(data.get('success')) + self.assertIn('run_uuid', data) + self.assertIsNotNone(data['run_uuid']) + self.assertIn('result_url', data) + + def test_submit_returns_uuid(self): + """Submitted run has a valid UUID.""" + payload = _make_submission_payload() + resp = self.client.post( + PREFIX + '/runs', + data=payload, + content_type='application/json', + headers=admin_headers(), + ) + data = resp.get_json() + run_uuid = data.get('run_uuid') + self.assertIsNotNone(run_uuid) + # Verify UUID format (should be valid UUID4) + try: + uuid.UUID(run_uuid, version=4) + except ValueError: + self.fail(f"run_uuid is not a valid UUID: {run_uuid}") + + def test_submit_run_appears_in_list(self): + """After submission, the run appears in the list endpoint.""" + machine_name = f'submit-list-{uuid.uuid4().hex[:8]}' + payload = _make_submission_payload(machine_name=machine_name) + resp = self.client.post( + PREFIX + '/runs', + data=payload, + content_type='application/json', + headers=admin_headers(), + ) + data = resp.get_json() + run_uuid = data['run_uuid'] + + # Verify the run appears in the list + list_resp = self.client.get( + PREFIX + f'/runs?machine={machine_name}') + list_data = list_resp.get_json() + uuids = [item['uuid'] for item in list_data['items']] + self.assertIn(run_uuid, uuids) + + def test_submit_run_detail_accessible(self): + """After submission, the run detail is accessible by UUID.""" + payload = _make_submission_payload() + resp = self.client.post( + PREFIX + '/runs', + data=payload, + content_type='application/json', + headers=admin_headers(), + ) + data = resp.get_json() + run_uuid = data['run_uuid'] + + # Fetch run detail + detail_resp = self.client.get(PREFIX + f'/runs/{run_uuid}') + self.assertEqual(detail_resp.status_code, 200) + detail = detail_resp.get_json() + self.assertEqual(detail['uuid'], run_uuid) + + def test_submit_invalid_payload_400(self): + """Submitting a JSON object without format_version returns 400.""" + resp = self.client.post( + PREFIX + '/runs', + data='{"not": "valid report"}', + content_type='application/json', + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 400) + data = resp.get_json() + self.assertIn('format_version', data['error']['message']) + + def test_submit_empty_body_400(self): + """Submitting an empty body returns 400.""" + resp = self.client.post( + PREFIX + '/runs', + data='', + content_type='application/json', + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 400) + + def test_submit_no_auth_401(self): + """Submitting without auth returns 401.""" + payload = _make_submission_payload() + resp = self.client.post( + PREFIX + '/runs', + data=payload, + content_type='application/json', + ) + self.assertEqual(resp.status_code, 401) + + def test_submit_read_scope_403(self): + """Submitting with read scope returns 403.""" + headers = make_scoped_headers(self.app, 'read') + payload = _make_submission_payload() + resp = self.client.post( + PREFIX + '/runs', + data=payload, + content_type='application/json', + headers=headers, + ) + self.assertEqual(resp.status_code, 403) + + def test_submit_with_submit_scope_succeeds(self): + """Submitting with submit scope succeeds.""" + headers = make_scoped_headers(self.app, 'submit') + payload = _make_submission_payload() + resp = self.client.post( + PREFIX + '/runs', + data=payload, + content_type='application/json', + headers=headers, + ) + self.assertIn(resp.status_code, [201, 301]) + + def test_submit_result_url_format(self): + """Result URL should point to the v5 run detail.""" + payload = _make_submission_payload() + resp = self.client.post( + PREFIX + '/runs', + data=payload, + content_type='application/json', + headers=admin_headers(), + ) + data = resp.get_json() + result_url = data.get('result_url') + self.assertIsNotNone(result_url) + self.assertIn(f'/api/v5/{TS}/runs/', result_url) + + +class TestRunSubmitFormatValidation(unittest.TestCase): + """Tests that POST /api/v5/{ts}/runs mandates JSON format_version '2'.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_submit_non_json_body_400(self): + """Non-JSON request body returns 400.""" + resp = self.client.post( + PREFIX + '/runs', + data='not json at all', + content_type='application/json', + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 400) + self.assertIn('JSON', resp.get_json()['error']['message']) + + def test_submit_json_array_body_400(self): + """A JSON array (not object) returns 400.""" + resp = self.client.post( + PREFIX + '/runs', + data='[1, 2, 3]', + content_type='application/json', + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 400) + self.assertIn('JSON object', resp.get_json()['error']['message']) + + def test_submit_missing_format_version_400(self): + """A JSON object without format_version returns 400.""" + payload = json.dumps({ + 'machine': {'name': 'dummy'}, + 'run': {'start_time': '2024-01-01', 'end_time': '2024-01-01', + 'llvm_project_revision': 'rev1'}, + 'tests': [], + }) + resp = self.client.post( + PREFIX + '/runs', + data=payload, + content_type='application/json', + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 400) + msg = resp.get_json()['error']['message'] + self.assertIn('format_version', msg) + self.assertIn('missing', msg) + + def test_submit_wrong_format_version_400(self): + """format_version '1' is rejected.""" + payload = json.dumps({ + 'format_version': '1', + 'machine': {'name': 'dummy'}, + 'run': {'start_time': '2024-01-01', 'end_time': '2024-01-01', + 'llvm_project_revision': 'rev1'}, + 'tests': [], + }) + resp = self.client.post( + PREFIX + '/runs', + data=payload, + content_type='application/json', + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 400) + msg = resp.get_json()['error']['message'] + self.assertIn('format_version', msg) + + def test_submit_integer_format_version_400(self): + """format_version as integer 2 (not string '2') is rejected.""" + payload = json.dumps({ + 'format_version': 2, + 'machine': {'name': 'dummy'}, + 'run': {'start_time': '2024-01-01', 'end_time': '2024-01-01', + 'llvm_project_revision': 'rev1'}, + 'tests': [], + }) + resp = self.client.post( + PREFIX + '/runs', + data=payload, + content_type='application/json', + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 400) + msg = resp.get_json()['error']['message'] + self.assertIn('format_version', msg) + + def test_submit_v2_format_accepted(self): + """A valid format_version '2' payload is accepted.""" + payload = _make_submission_payload() + resp = self.client.post( + PREFIX + '/runs', + data=payload, + content_type='application/json', + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 201) + self.assertTrue(resp.get_json().get('success')) + + +class TestRunSubmitMachineConflict(unittest.TestCase): + """Tests for the on_machine_conflict query parameter on POST /runs.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_default_is_reject(self): + """Omitting on_machine_conflict uses reject by default.""" + payload = _make_submission_payload() + resp = self.client.post( + PREFIX + '/runs', + data=payload, + content_type='application/json', + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 201) + self.assertTrue(resp.get_json().get('success')) + + def test_reject_value_accepted(self): + """on_machine_conflict=reject is accepted.""" + payload = _make_submission_payload() + resp = self.client.post( + PREFIX + '/runs?on_machine_conflict=reject', + data=payload, + content_type='application/json', + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 201) + + def test_update_value_accepted(self): + """on_machine_conflict=update is accepted.""" + payload = _make_submission_payload() + resp = self.client.post( + PREFIX + '/runs?on_machine_conflict=update', + data=payload, + content_type='application/json', + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 201) + + def test_invalid_value_returns_422(self): + """An invalid on_machine_conflict value returns 422.""" + payload = _make_submission_payload() + resp = self.client.post( + PREFIX + '/runs?on_machine_conflict=bogus', + data=payload, + content_type='application/json', + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 422) + + +def _make_submission_with_info(machine_name, machine_info, revision=None): + """Build a v2-format JSON submission payload with machine info fields.""" + if revision is None: + revision = f'r{uuid.uuid4().hex[:8]}' + machine = {'name': machine_name} + machine.update(machine_info) + return json.dumps({ + 'format_version': '2', + 'machine': machine, + 'run': { + 'start_time': '2024-06-15T10:00:00', + 'end_time': '2024-06-15T10:30:00', + 'llvm_project_revision': revision, + }, + 'tests': [ + { + 'name': 'test.suite/benchmark1', + 'execution_time': [0.1234], + }, + ], + }) + + +class TestMachineConflictUpdateBehavior(unittest.TestCase): + """Behavioral tests for on_machine_conflict=update on POST /runs. + + These tests verify that the 'update' strategy actually modifies + the existing machine's info rather than creating a duplicate. + """ + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def _submit_run(self, machine_name, machine_info, conflict='update'): + """Helper: submit a run with the given machine info and conflict mode.""" + payload = _make_submission_with_info(machine_name, machine_info) + url = PREFIX + '/runs' + if conflict is not None: + url += f'?on_machine_conflict={conflict}' + return self.client.post( + url, + data=payload, + content_type='application/json', + headers=admin_headers(), + ) + + def _get_machine(self, machine_name): + """Helper: GET a machine by name and return (status_code, json).""" + resp = self.client.get(PREFIX + f'/machines/{machine_name}') + return resp.status_code, resp.get_json() + + def _list_machines_by_name(self, machine_name): + """Helper: list machines filtered by exact name prefix.""" + resp = self.client.get( + PREFIX + f'/machines?name_prefix={machine_name}') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + # Filter to exact name matches (name_prefix could match longer names) + return [m for m in data['items'] if m['name'] == machine_name] + + def test_update_does_not_create_new_machine(self): + """on_machine_conflict=update reuses the existing machine, no duplicate.""" + name = f'mc-update-nodup-{uuid.uuid4().hex[:8]}' + + # First submission creates the machine. + resp1 = self._submit_run(name, {'os': 'Linux'}) + self.assertEqual(resp1.status_code, 201) + + # Second submission with different info and update mode. + resp2 = self._submit_run(name, {'os': 'Linux-v2'}, conflict='update') + self.assertEqual(resp2.status_code, 201) + + # Verify only one machine with this name exists. + machines = self._list_machines_by_name(name) + self.assertEqual(len(machines), 1, + f"Expected 1 machine named '{name}', got {len(machines)}") + + def test_update_changes_machine_info(self): + """on_machine_conflict=update actually modifies the machine's info.""" + name = f'mc-update-info-{uuid.uuid4().hex[:8]}' + + # First submission creates the machine with os=Linux. + resp1 = self._submit_run(name, {'os': 'Linux'}) + self.assertEqual(resp1.status_code, 201) + + # Verify initial info. + status, data = self._get_machine(name) + self.assertEqual(status, 200) + self.assertEqual(data['info']['os'], 'Linux') + + # Second submission with updated os. + resp2 = self._submit_run(name, {'os': 'Linux-v2'}, conflict='update') + self.assertEqual(resp2.status_code, 201) + + # Verify updated info. + status, data = self._get_machine(name) + self.assertEqual(status, 200) + self.assertEqual(data['info']['os'], 'Linux-v2') + + def test_reject_default_raises_on_conflict(self): + """Default reject mode returns 400 when machine info has changed.""" + name = f'mc-reject-err-{uuid.uuid4().hex[:8]}' + + # First submission creates the machine. + resp1 = self._submit_run(name, {'os': 'Linux'}, conflict=None) + self.assertEqual(resp1.status_code, 201) + + # Second submission with different info and default (reject) mode. + resp2 = self._submit_run(name, {'os': 'Linux-v2'}, conflict=None) + self.assertEqual(resp2.status_code, 400) + + def test_update_with_same_info_succeeds(self): + """on_machine_conflict=update with identical info succeeds, no duplicate.""" + name = f'mc-update-same-{uuid.uuid4().hex[:8]}' + + # Both submissions use the same info. + resp1 = self._submit_run(name, {'os': 'Linux'}, conflict='update') + self.assertEqual(resp1.status_code, 201) + + resp2 = self._submit_run(name, {'os': 'Linux'}, conflict='update') + self.assertEqual(resp2.status_code, 201) + + # Still only one machine. + machines = self._list_machines_by_name(name) + self.assertEqual(len(machines), 1, + f"Expected 1 machine named '{name}', got {len(machines)}") + + def test_update_preserves_existing_fields_when_new_is_null(self): + """on_machine_conflict=update preserves fields not in the new submission.""" + name = f'mc-update-preserve-{uuid.uuid4().hex[:8]}' + + # First submission with both os and arch. + resp1 = self._submit_run(name, {'os': 'Linux', 'arch': 'x86_64'}) + self.assertEqual(resp1.status_code, 201) + + # Verify both fields are set. + status, data = self._get_machine(name) + self.assertEqual(status, 200) + self.assertEqual(data['info']['os'], 'Linux') + self.assertEqual(data['info']['arch'], 'x86_64') + + # Second submission with only os (no arch). + resp2 = self._submit_run(name, {'os': 'Linux-v2'}, conflict='update') + self.assertEqual(resp2.status_code, 201) + + # Verify os is updated but arch is preserved. + status, data = self._get_machine(name) + self.assertEqual(status, 200) + self.assertEqual(data['info']['os'], 'Linux-v2') + self.assertEqual(data['info']['arch'], 'x86_64') + + +class TestRunSubmitOnExistingRun(unittest.TestCase): + """Tests for the on_existing_run query parameter on POST /runs.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_default_is_reject(self): + """Omitting on_existing_run uses reject by default.""" + payload = _make_submission_payload() + resp = self.client.post( + PREFIX + '/runs', + data=payload, + content_type='application/json', + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 201) + self.assertTrue(resp.get_json().get('success')) + + def test_reject_value_accepted(self): + """on_existing_run=reject is accepted.""" + payload = _make_submission_payload() + resp = self.client.post( + PREFIX + '/runs?on_existing_run=reject', + data=payload, + content_type='application/json', + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 201) + + def test_replace_value_accepted(self): + """on_existing_run=replace is accepted.""" + payload = _make_submission_payload() + resp = self.client.post( + PREFIX + '/runs?on_existing_run=replace', + data=payload, + content_type='application/json', + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 201) + + def test_create_value_accepted(self): + """on_existing_run=create is accepted.""" + payload = _make_submission_payload() + resp = self.client.post( + PREFIX + '/runs?on_existing_run=create', + data=payload, + content_type='application/json', + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 201) + + def test_invalid_value_returns_422(self): + """An invalid on_existing_run value returns 422.""" + payload = _make_submission_payload() + resp = self.client.post( + PREFIX + '/runs?on_existing_run=bogus', + data=payload, + content_type='application/json', + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 422) + + +class TestRunDetail(unittest.TestCase): + """Tests for GET /api/v5/{ts}/runs/{uuid}.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_get_run_detail(self): + """Get run detail by UUID.""" + name = f'detail-{uuid.uuid4().hex[:8]}' + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + machine = create_machine(session, ts, name=name) + order = create_order(session, ts, revision=f'detail-rev-{uuid.uuid4().hex[:6]}') + run = create_run(session, ts, machine, order) + run_uuid = run.uuid + session.commit() + session.close() + + resp = self.client.get(PREFIX + f'/runs/{run_uuid}') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertEqual(data['uuid'], run_uuid) + self.assertEqual(data['machine'], name) + self.assertIn('order', data) + self.assertIn('start_time', data) + self.assertIn('end_time', data) + self.assertIn('parameters', data) + + def test_get_run_detail_has_no_internal_ids(self): + """Run detail does not expose internal IDs.""" + name = f'detail-noid-{uuid.uuid4().hex[:8]}' + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + machine = create_machine(session, ts, name=name) + order = create_order(session, ts, revision=f'noid-detail-rev-{uuid.uuid4().hex[:6]}') + run = create_run(session, ts, machine, order) + run_uuid = run.uuid + session.commit() + session.close() + + resp = self.client.get(PREFIX + f'/runs/{run_uuid}') + data = resp.get_json() + self.assertNotIn('id', data) + self.assertNotIn('machine_id', data) + self.assertNotIn('order_id', data) + + def test_get_nonexistent_uuid_404(self): + """Getting a run with a nonexistent UUID returns 404.""" + fake_uuid = str(uuid.uuid4()) + resp = self.client.get(PREFIX + f'/runs/{fake_uuid}') + self.assertEqual(resp.status_code, 404) + + def test_get_invalid_uuid_format_404(self): + """Getting a run with an invalid UUID string returns 404.""" + resp = self.client.get(PREFIX + '/runs/not-a-valid-uuid') + self.assertEqual(resp.status_code, 404) + + +class TestRunDetailETag(unittest.TestCase): + """ETag tests for GET /api/v5/{ts}/runs/{uuid}.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_etag_present_on_detail(self): + """Run detail response should include an ETag header.""" + name = f'etag-present-{uuid.uuid4().hex[:8]}' + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + machine = create_machine(session, ts, name=name) + order = create_order(session, ts, + revision=f'etag-rev-{uuid.uuid4().hex[:6]}') + run = create_run(session, ts, machine, order) + run_uuid = run.uuid + session.commit() + session.close() + + resp = self.client.get(PREFIX + f'/runs/{run_uuid}') + self.assertEqual(resp.status_code, 200) + etag = resp.headers.get('ETag') + self.assertIsNotNone(etag) + self.assertTrue(etag.startswith('W/"')) + + def test_etag_304_on_match(self): + """Sending If-None-Match with the same ETag returns 304.""" + name = f'etag-304-{uuid.uuid4().hex[:8]}' + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + machine = create_machine(session, ts, name=name) + order = create_order(session, ts, + revision=f'etag-304-rev-{uuid.uuid4().hex[:6]}') + run = create_run(session, ts, machine, order) + run_uuid = run.uuid + session.commit() + session.close() + + resp = self.client.get(PREFIX + f'/runs/{run_uuid}') + etag = resp.headers.get('ETag') + + resp2 = self.client.get( + PREFIX + f'/runs/{run_uuid}', + headers={'If-None-Match': etag}, + ) + self.assertEqual(resp2.status_code, 304) + + def test_etag_200_on_mismatch(self): + """Sending If-None-Match with a different ETag returns 200.""" + name = f'etag-200-{uuid.uuid4().hex[:8]}' + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + machine = create_machine(session, ts, name=name) + order = create_order(session, ts, + revision=f'etag-200-rev-{uuid.uuid4().hex[:6]}') + run = create_run(session, ts, machine, order) + run_uuid = run.uuid + session.commit() + session.close() + + resp = self.client.get( + PREFIX + f'/runs/{run_uuid}', + headers={'If-None-Match': 'W/"stale-etag-value"'}, + ) + self.assertEqual(resp.status_code, 200) + self.assertIsNotNone(resp.get_json()) + + +class TestRunDelete(unittest.TestCase): + """Tests for DELETE /api/v5/{ts}/runs/{uuid}.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_delete_run(self): + """Delete a run and verify 204, then verify it's gone.""" + name = f'delete-{uuid.uuid4().hex[:8]}' + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + machine = create_machine(session, ts, name=name) + order = create_order(session, ts, revision=f'del-rev-{uuid.uuid4().hex[:6]}') + run = create_run(session, ts, machine, order) + run_uuid = run.uuid + session.commit() + session.close() + + resp = self.client.delete( + PREFIX + f'/runs/{run_uuid}', + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 204) + + # Verify it's gone + resp = self.client.get(PREFIX + f'/runs/{run_uuid}') + self.assertEqual(resp.status_code, 404) + + def test_delete_nonexistent_404(self): + """Deleting a nonexistent run returns 404.""" + fake_uuid = str(uuid.uuid4()) + resp = self.client.delete( + PREFIX + f'/runs/{fake_uuid}', + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 404) + + def test_delete_no_auth_401(self): + """Deleting without auth returns 401.""" + name = f'del-noauth-{uuid.uuid4().hex[:8]}' + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + machine = create_machine(session, ts, name=name) + order = create_order(session, ts, revision=f'del-noauth-{uuid.uuid4().hex[:6]}') + run = create_run(session, ts, machine, order) + run_uuid = run.uuid + session.commit() + session.close() + + resp = self.client.delete(PREFIX + f'/runs/{run_uuid}') + self.assertEqual(resp.status_code, 401) + + def test_delete_without_manage_scope_403(self): + """Deleting with submit scope (not manage) returns 403.""" + name = f'del-scope-{uuid.uuid4().hex[:8]}' + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + machine = create_machine(session, ts, name=name) + order = create_order(session, ts, revision=f'del-scope-{uuid.uuid4().hex[:6]}') + run = create_run(session, ts, machine, order) + run_uuid = run.uuid + session.commit() + session.close() + + headers = make_scoped_headers(self.app, 'submit') + resp = self.client.delete( + PREFIX + f'/runs/{run_uuid}', + headers=headers, + ) + self.assertEqual(resp.status_code, 403) + + +class TestRunFilterByMachine(unittest.TestCase): + """Test filtering runs by machine name.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_filter_by_machine_name(self): + """Filter runs by machine name.""" + name = f'filter-machine-{uuid.uuid4().hex[:8]}' + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + machine = create_machine(session, ts, name=name) + order = create_order(session, ts, revision=f'fm-rev-{uuid.uuid4().hex[:6]}') + create_run(session, ts, machine, order) + session.commit() + session.close() + + resp = self.client.get(PREFIX + f'/runs?machine={name}') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertGreater(len(data['items']), 0) + for item in data['items']: + self.assertEqual(item['machine'], name) + + def test_filter_by_nonexistent_machine(self): + """Filtering by a machine that doesn't exist returns empty results.""" + resp = self.client.get( + PREFIX + '/runs?machine=nonexistent-machine-xyz-abc') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertEqual(len(data['items']), 0) + + +class TestRunFilterByDatetime(unittest.TestCase): + """Test filtering runs by after/before datetime.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_filter_after(self): + """Filter runs started after a given datetime.""" + name = f'after-{uuid.uuid4().hex[:8]}' + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + machine = create_machine(session, ts, name=name) + order1 = create_order(session, ts, revision=f'after-rev1-{uuid.uuid4().hex[:6]}') + create_run(session, ts, machine, order1, + start_time=datetime.datetime(2024, 1, 1, 12, 0, 0), + end_time=datetime.datetime(2024, 1, 1, 13, 0, 0)) + order2 = create_order(session, ts, revision=f'after-rev2-{uuid.uuid4().hex[:6]}') + create_run(session, ts, machine, order2, + start_time=datetime.datetime(2024, 6, 1, 12, 0, 0), + end_time=datetime.datetime(2024, 6, 1, 13, 0, 0)) + session.commit() + session.close() + + resp = self.client.get( + PREFIX + f'/runs?machine={name}&after=2024-03-01T00:00:00') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertEqual(len(data['items']), 1) + + def test_filter_before(self): + """Filter runs started before a given datetime.""" + name = f'before-{uuid.uuid4().hex[:8]}' + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + machine = create_machine(session, ts, name=name) + order1 = create_order(session, ts, revision=f'before-rev1-{uuid.uuid4().hex[:6]}') + create_run(session, ts, machine, order1, + start_time=datetime.datetime(2024, 1, 1, 12, 0, 0), + end_time=datetime.datetime(2024, 1, 1, 13, 0, 0)) + order2 = create_order(session, ts, revision=f'before-rev2-{uuid.uuid4().hex[:6]}') + create_run(session, ts, machine, order2, + start_time=datetime.datetime(2024, 6, 1, 12, 0, 0), + end_time=datetime.datetime(2024, 6, 1, 13, 0, 0)) + session.commit() + session.close() + + resp = self.client.get( + PREFIX + f'/runs?machine={name}&before=2024-03-01T00:00:00') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertEqual(len(data['items']), 1) + + def test_filter_after_and_before(self): + """Filter runs within a datetime range.""" + name = f'range-{uuid.uuid4().hex[:8]}' + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + machine = create_machine(session, ts, name=name) + for month in (1, 4, 7, 10): + order = create_order(session, ts, + revision=f'range-rev-{month}-{uuid.uuid4().hex[:6]}') + create_run(session, ts, machine, order, + start_time=datetime.datetime(2024, month, 15, 12, 0, 0), + end_time=datetime.datetime(2024, month, 15, 13, 0, 0)) + session.commit() + session.close() + + resp = self.client.get( + PREFIX + f'/runs?machine={name}&after=2024-03-01T00:00:00&before=2024-08-01T00:00:00') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + # Should match runs from month 4 and 7 + self.assertEqual(len(data['items']), 2) + + def test_filter_invalid_after_datetime_400(self): + """Invalid after datetime returns 400.""" + resp = self.client.get(PREFIX + '/runs?after=not-a-date') + self.assertEqual(resp.status_code, 400) + + def test_filter_invalid_before_datetime_400(self): + """Invalid before datetime returns 400.""" + resp = self.client.get(PREFIX + '/runs?before=not-a-date') + self.assertEqual(resp.status_code, 400) + + +class TestRunFilterByOrder(unittest.TestCase): + """Test filtering runs by order (primary order field value).""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_filter_by_order_value(self): + """Filter runs by primary order field value.""" + name = f'order-filter-{uuid.uuid4().hex[:8]}' + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + machine = create_machine(session, ts, name=name) + rev1 = f'ofilt-rev1-{uuid.uuid4().hex[:6]}' + rev2 = f'ofilt-rev2-{uuid.uuid4().hex[:6]}' + order1 = create_order(session, ts, revision=rev1) + order2 = create_order(session, ts, revision=rev2) + create_run(session, ts, machine, order1) + create_run(session, ts, machine, order2) + session.commit() + session.close() + + resp = self.client.get( + PREFIX + f'/runs?machine={name}&order={rev1}') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertEqual(len(data['items']), 1) + self.assertIn(rev1, data['items'][0]['order'].values()) + + def test_filter_by_nonexistent_order(self): + """Filtering by a nonexistent order returns empty results.""" + resp = self.client.get( + PREFIX + '/runs?order=nonexistent-revision-xyz-abc') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertEqual(len(data['items']), 0) + + +class TestRunSort(unittest.TestCase): + """Test sorting runs.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_sort_descending_start_time(self): + """Sort runs by -start_time returns newest first.""" + name = f'sort-run-{uuid.uuid4().hex[:8]}' + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + machine = create_machine(session, ts, name=name) + for month in (1, 4, 7): + order = create_order( + session, ts, + revision=f'sort-rev-{month}-{uuid.uuid4().hex[:6]}') + create_run(session, ts, machine, order, + start_time=datetime.datetime(2024, month, 1, 12, 0, 0), + end_time=datetime.datetime(2024, month, 1, 13, 0, 0)) + session.commit() + session.close() + + # Default order (ascending by ID) + resp_default = self.client.get( + PREFIX + f'/runs?machine={name}') + self.assertEqual(resp_default.status_code, 200) + default_times = [ + item['start_time'] for item in resp_default.get_json()['items']] + + # Descending by start_time + resp_sorted = self.client.get( + PREFIX + f'/runs?machine={name}&sort=-start_time') + self.assertEqual(resp_sorted.status_code, 200) + sorted_times = [ + item['start_time'] for item in resp_sorted.get_json()['items']] + + self.assertEqual(len(sorted_times), 3) + self.assertEqual(sorted_times, list(reversed(default_times))) + + +class TestRunPagination(unittest.TestCase): + """Exhaustive cursor pagination tests for GET /api/v5/{ts}/runs.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + cls._machine_name = f'pag-machine-{uuid.uuid4().hex[:8]}' + db = cls.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + machine = create_machine(session, ts, name=cls._machine_name) + for i in range(5): + order = create_order( + session, ts, + revision=f'pag-run-rev-{uuid.uuid4().hex[:6]}-{i}') + create_run(session, ts, machine, order, + start_time=datetime.datetime(2024, 1, 1 + i, 12, 0, 0)) + session.commit() + session.close() + + def _collect_all_pages(self): + url = PREFIX + f'/runs?machine={self._machine_name}&limit=2' + return collect_all_pages(self, self.client, url) + + def test_pagination_collects_all_items(self): + """Paginating through all pages collects all 5 runs.""" + all_items = self._collect_all_pages() + self.assertEqual(len(all_items), 5) + + def test_no_duplicate_items_across_pages(self): + """No duplicate run UUIDs across pages.""" + all_items = self._collect_all_pages() + uuids = [item['uuid'] for item in all_items] + self.assertEqual(len(uuids), len(set(uuids))) + + +class TestRunListInvalidCursor(unittest.TestCase): + """Tests that an invalid cursor returns 400 for the run list endpoint.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_invalid_cursor_returns_400(self): + """An invalid cursor string should return 400.""" + resp = self.client.get( + PREFIX + '/runs?cursor=not-a-valid-cursor!!!') + self.assertEqual(resp.status_code, 400) + + +class TestRunUnknownParams(unittest.TestCase): + """Test that unknown query parameters are rejected with 400.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_runs_list_unknown_param_returns_400(self): + resp = self.client.get(PREFIX + '/runs?bogus=1') + self.assertEqual(resp.status_code, 400) + data = resp.get_json() + self.assertIn('bogus', data['error']['message']) + + def test_run_detail_unknown_param_returns_400(self): + name = f'unk-det-{uuid.uuid4().hex[:8]}' + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + machine = create_machine(session, ts, name=name) + order = create_order(session, ts, revision=f'unk-det-rev-{uuid.uuid4().hex[:6]}') + run = create_run(session, ts, machine, order) + run_uuid = run.uuid + session.commit() + session.close() + resp = self.client.get(PREFIX + f'/runs/{run_uuid}?bogus=1') + self.assertEqual(resp.status_code, 400) + + def test_run_submit_ignore_regressions_rejected(self): + """ignore_regressions is no longer accepted by v5 POST /runs.""" + headers = admin_headers() + headers['Content-Type'] = 'application/json' + body = json.dumps({ + 'format_version': '2', + 'machine': {'name': 'dummy'}, + 'run': {'start_time': '2024-01-01', 'end_time': '2024-01-01', + 'llvm_project_revision': 'rev-ignore-test'}, + 'tests': [], + }) + resp = self.client.post( + PREFIX + '/runs?ignore_regressions=true', + data=body, + headers=headers, + ) + self.assertEqual(resp.status_code, 400) + data = resp.get_json() + self.assertIn('ignore_regressions', data['error']['message']) + + +if __name__ == '__main__': + unittest.main(argv=[sys.argv[0]], exit=True) diff --git a/tests/server/api/v5/test_samples.py b/tests/server/api/v5/test_samples.py new file mode 100644 index 000000000..1fb2c4db6 --- /dev/null +++ b/tests/server/api/v5/test_samples.py @@ -0,0 +1,468 @@ +# Tests for the v5 sample endpoints. +# +# RUN: rm -rf %t.instance %t.pg.log +# RUN: %{utils}/with_postgres.sh %t.pg.log \ +# RUN: %{utils}/with_temporary_instance.py %t.instance \ +# RUN: -- python %s %t.instance +# END. + +import base64 +import os +import pickle +import sys +import unittest +import uuid +import zlib + +sys.path.insert(0, os.path.dirname(__file__)) +from v5_test_helpers import ( + create_app, create_client, make_scoped_headers, + create_machine, create_order, create_run, create_test, create_sample, + collect_all_pages, +) + +TS = 'nts' +PREFIX = f'/api/v5/{TS}' + +# Profile data in the ProfileV1 format +SAMPLE_PROFILE_DATA = { + 'counters': {'cycles': 12345.0, 'branch-misses': 200.0}, + 'disassembly-format': 'raw', + 'functions': { + 'main': { + 'counters': {'cycles': 80.0}, + 'data': [ + [0x1000, {'cycles': 50.0}, '\tadd r0, r0, r1'], + ], + }, + }, +} + + +def _make_encoded_profile(profile_data=None): + """Create a base64-encoded profile string suitable for the Profile + constructor.""" + if profile_data is None: + profile_data = SAMPLE_PROFILE_DATA + compressed = zlib.compress(pickle.dumps(profile_data)) + return base64.b64encode(compressed).decode('ascii') + + +class _MockConfig(object): + """Mock config object for Profile.__init__. + + Profile.__init__ accesses config.config.profileDir. + """ + def __init__(self, profile_dir): + self.config = self + self.profileDir = profile_dir + + +def _create_sample_with_profile(session, ts, run, test, profile_dir): + """Create a sample with an associated profile record on disk.""" + encoded = _make_encoded_profile() + config = _MockConfig(profile_dir) + profile_obj = ts.Profile(encoded, config, test.name) + session.add(profile_obj) + session.flush() + + sample = ts.Sample(run, test) + sample.profile_id = profile_obj.id + session.add(sample) + session.flush() + return sample + + +class TestRunSamples(unittest.TestCase): + """Tests for GET /api/v5/{ts}/runs/{uuid}/samples.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def _setup_run_with_samples(self): + """Create a run with several samples for testing.""" + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite['nts'] + + machine = create_machine( + session, ts, f'sample-test-machine-{uuid.uuid4().hex[:8]}') + order = create_order( + session, ts, revision=f'sample-rev-{uuid.uuid4().hex[:8]}') + run = create_run(session, ts, machine, order) + + test1 = create_test( + session, ts, f'test.suite/bench1-{uuid.uuid4().hex[:8]}') + test2 = create_test( + session, ts, f'test.suite/bench2-{uuid.uuid4().hex[:8]}') + + create_sample(session, ts, run, test1) + create_sample(session, ts, run, test2) + + session.commit() + # Save values before closing session to avoid DetachedInstanceError + run_uuid = run.uuid + test1_name = test1.name + test2_name = test2.name + session.close() + return run_uuid, test1_name, test2_name + + def test_list_samples_empty_run(self): + """A run with no samples returns an empty list.""" + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite['nts'] + machine = create_machine( + session, ts, f'empty-run-machine-{uuid.uuid4().hex[:8]}') + order = create_order( + session, ts, revision=f'empty-rev-{uuid.uuid4().hex[:8]}') + run = create_run(session, ts, machine, order) + session.commit() + run_uuid = run.uuid + session.close() + + resp = self.client.get(PREFIX + f'/runs/{run_uuid}/samples') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertIn('items', data) + self.assertEqual(len(data['items']), 0) + + def test_list_samples_with_data(self): + """A run with samples returns them.""" + run_uuid, test1_name, test2_name = self._setup_run_with_samples() + + resp = self.client.get(PREFIX + f'/runs/{run_uuid}/samples') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertIn('items', data) + self.assertGreaterEqual(len(data['items']), 2) + + # Verify sample structure + sample = data['items'][0] + self.assertIn('test', sample) + self.assertIn('has_profile', sample) + self.assertIn('metrics', sample) + self.assertIsInstance(sample['metrics'], dict) + + def test_list_samples_has_pagination(self): + """Sample list has pagination envelope.""" + run_uuid, _, _ = self._setup_run_with_samples() + resp = self.client.get(PREFIX + f'/runs/{run_uuid}/samples') + data = resp.get_json() + self.assertIn('cursor', data) + self.assertIn('next', data['cursor']) + self.assertIn('previous', data['cursor']) + + def test_list_samples_nonexistent_run(self): + """404 for a nonexistent run UUID.""" + fake_uuid = str(uuid.uuid4()) + resp = self.client.get(PREFIX + f'/runs/{fake_uuid}/samples') + self.assertEqual(resp.status_code, 404) + + def test_list_samples_has_profile_filter(self): + """The has_profile=true filter returns only profiled samples.""" + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite['nts'] + + machine = create_machine( + session, ts, f'profile-filter-machine-{uuid.uuid4().hex[:8]}') + order = create_order( + session, ts, revision=f'pf-rev-{uuid.uuid4().hex[:8]}') + run = create_run(session, ts, machine, order) + + test_no_profile = create_test( + session, ts, + f'test.suite/no-profile-{uuid.uuid4().hex[:8]}') + test_with_profile = create_test( + session, ts, + f'test.suite/with-profile-{uuid.uuid4().hex[:8]}') + + # Sample without profile + create_sample(session, ts, run, test_no_profile) + + # Sample with profile + profile_dir = self.app.old_config.profileDir + _create_sample_with_profile( + session, ts, run, test_with_profile, profile_dir) + + session.commit() + run_uuid = run.uuid + session.close() + + # Without filter: should return both + resp = self.client.get(PREFIX + f'/runs/{run_uuid}/samples') + self.assertEqual(resp.status_code, 200) + all_items = resp.get_json()['items'] + self.assertGreaterEqual(len(all_items), 2) + + # With filter: should return only the one with profile + resp = self.client.get( + PREFIX + f'/runs/{run_uuid}/samples?has_profile=true') + self.assertEqual(resp.status_code, 200) + profiled_items = resp.get_json()['items'] + self.assertGreaterEqual(len(profiled_items), 1) + for item in profiled_items: + self.assertTrue(item['has_profile']) + + def test_list_samples_has_profile_false_returns_all(self): + """has_profile with a non-true value does not filter.""" + run_uuid, _, _ = self._setup_run_with_samples() + resp = self.client.get( + PREFIX + f'/runs/{run_uuid}/samples?has_profile=false') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertIn('items', data) + + def test_invalid_cursor_returns_400(self): + """An invalid cursor string should return 400.""" + run_uuid, _, _ = self._setup_run_with_samples() + resp = self.client.get( + PREFIX + f'/runs/{run_uuid}/samples?cursor=not-a-valid-cursor!!!') + self.assertEqual(resp.status_code, 400) + + +class TestRunTestSamples(unittest.TestCase): + """Tests for GET /api/v5/{ts}/runs/{uuid}/tests/{test_name}/samples.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def _setup_run_with_samples(self): + """Create a run with samples for testing.""" + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite['nts'] + + machine = create_machine( + session, ts, f'test-sample-machine-{uuid.uuid4().hex[:8]}') + order = create_order( + session, ts, revision=f'ts-rev-{uuid.uuid4().hex[:8]}') + run = create_run(session, ts, machine, order) + + test = create_test( + session, ts, f'test.suite/specific-{uuid.uuid4().hex[:8]}') + create_sample(session, ts, run, test) + + session.commit() + run_uuid = run.uuid + test_name = test.name + session.close() + return run_uuid, test_name + + def test_samples_for_specific_test(self): + """Get samples for a specific test in a run.""" + run_uuid, test_name = self._setup_run_with_samples() + + resp = self.client.get( + PREFIX + f'/runs/{run_uuid}/tests/{test_name}/samples') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertIn('items', data) + self.assertGreaterEqual(len(data['items']), 1) + self.assertEqual(data['items'][0]['test'], test_name) + + def test_samples_for_nonexistent_run(self): + """404 for a nonexistent run UUID.""" + fake_uuid = str(uuid.uuid4()) + resp = self.client.get( + PREFIX + f'/runs/{fake_uuid}/tests/some.test/samples') + self.assertEqual(resp.status_code, 404) + + def test_samples_for_nonexistent_test(self): + """404 for a nonexistent test name.""" + # Create a real run first + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite['nts'] + machine = create_machine( + session, ts, f'nonexist-test-machine-{uuid.uuid4().hex[:8]}') + order = create_order( + session, ts, revision=f'ne-rev-{uuid.uuid4().hex[:8]}') + run = create_run(session, ts, machine, order) + session.commit() + run_uuid = run.uuid + session.close() + + resp = self.client.get( + PREFIX + f'/runs/{run_uuid}/tests/no.such.test/samples') + self.assertEqual(resp.status_code, 404) + + def test_samples_test_name_with_slashes(self): + """Test names with slashes work (using path converter).""" + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite['nts'] + + machine = create_machine( + session, ts, f'slash-machine-{uuid.uuid4().hex[:8]}') + order = create_order( + session, ts, revision=f'sl-rev-{uuid.uuid4().hex[:8]}') + run = create_run(session, ts, machine, order) + + # Test name with slashes + test_name = f'test/suite/sub/bench-{uuid.uuid4().hex[:8]}' + test = create_test(session, ts, test_name) + create_sample(session, ts, run, test) + + session.commit() + run_uuid = run.uuid + session.close() + + resp = self.client.get( + PREFIX + f'/runs/{run_uuid}/tests/{test_name}/samples') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertIn('items', data) + self.assertEqual(len(data['items']), 1) + self.assertEqual(data['items'][0]['test'], test_name) + + def test_samples_returns_metrics(self): + """Sample response includes metrics dict with field values.""" + run_uuid, test_name = self._setup_run_with_samples() + resp = self.client.get( + PREFIX + f'/runs/{run_uuid}/tests/{test_name}/samples') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertGreaterEqual(len(data['items']), 1) + sample = data['items'][0] + self.assertIn('metrics', sample) + self.assertIsInstance(sample['metrics'], dict) + + +class TestSampleAuth(unittest.TestCase): + """Auth tests for sample endpoints (all use @require_scope('read')).""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + # Create a run with samples for testing + db = cls.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite['nts'] + machine = create_machine( + session, ts, f'auth-sample-machine-{uuid.uuid4().hex[:8]}') + order = create_order( + session, ts, revision=f'auth-sample-rev-{uuid.uuid4().hex[:8]}') + run = create_run(session, ts, machine, order) + test = create_test( + session, ts, f'test.suite/auth-bench-{uuid.uuid4().hex[:8]}') + create_sample(session, ts, run, test) + session.commit() + cls._run_uuid = run.uuid + cls._test_name = test.name + session.close() + + def test_run_samples_no_auth_allowed(self): + """Unauthenticated GET for run samples is allowed by default.""" + resp = self.client.get( + PREFIX + f'/runs/{self._run_uuid}/samples') + self.assertEqual(resp.status_code, 200) + + def test_run_samples_read_scope_allowed(self): + """A valid read-scoped token works for run samples.""" + headers = make_scoped_headers(self.app, 'read') + resp = self.client.get( + PREFIX + f'/runs/{self._run_uuid}/samples', + headers=headers) + self.assertEqual(resp.status_code, 200) + + def test_test_samples_no_auth_allowed(self): + """Unauthenticated GET for test-specific samples is allowed by default.""" + resp = self.client.get( + PREFIX + f'/runs/{self._run_uuid}/tests/{self._test_name}/samples') + self.assertEqual(resp.status_code, 200) + + def test_test_samples_read_scope_allowed(self): + """A valid read-scoped token works for test-specific samples.""" + headers = make_scoped_headers(self.app, 'read') + resp = self.client.get( + PREFIX + f'/runs/{self._run_uuid}/tests/{self._test_name}/samples', + headers=headers) + self.assertEqual(resp.status_code, 200) + + +class TestSamplePagination(unittest.TestCase): + """Exhaustive cursor pagination tests for GET /api/v5/{ts}/runs/{uuid}/samples.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + db = cls.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite['nts'] + machine = create_machine( + session, ts, f'pag-sample-m-{uuid.uuid4().hex[:8]}') + order = create_order( + session, ts, revision=f'pag-sample-rev-{uuid.uuid4().hex[:8]}') + run = create_run(session, ts, machine, order) + for i in range(5): + test = create_test( + session, ts, + f'pag-sample/test-{uuid.uuid4().hex[:8]}-{i}') + create_sample(session, ts, run, test) + session.commit() + cls._run_uuid = run.uuid + session.close() + + def _collect_all_pages(self): + url = PREFIX + f'/runs/{self._run_uuid}/samples?limit=2' + return collect_all_pages(self, self.client, url) + + def test_pagination_collects_all_items(self): + """Paginating through all pages collects all 5 samples.""" + all_items = self._collect_all_pages() + self.assertEqual(len(all_items), 5) + + def test_no_duplicate_items_across_pages(self): + """No duplicate test names across pages.""" + all_items = self._collect_all_pages() + names = [item['test'] for item in all_items] + self.assertEqual(len(names), len(set(names))) + + +class TestSampleUnknownParams(unittest.TestCase): + """Test that unknown query parameters are rejected with 400.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + db = cls.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite['nts'] + machine = create_machine( + session, ts, f'unk-sample-machine-{uuid.uuid4().hex[:8]}') + order = create_order( + session, ts, revision=f'unk-sample-rev-{uuid.uuid4().hex[:8]}') + run = create_run(session, ts, machine, order) + test = create_test( + session, ts, f'test.suite/unk-bench-{uuid.uuid4().hex[:8]}') + create_sample(session, ts, run, test) + session.commit() + cls._run_uuid = run.uuid + cls._test_name = test.name + session.close() + + def test_run_samples_unknown_param_returns_400(self): + resp = self.client.get( + PREFIX + f'/runs/{self._run_uuid}/samples?bogus=1') + self.assertEqual(resp.status_code, 400) + data = resp.get_json() + self.assertIn('bogus', data['error']['message']) + + def test_test_samples_unknown_param_returns_400(self): + resp = self.client.get( + PREFIX + f'/runs/{self._run_uuid}/tests/{self._test_name}/samples?bogus=1') + self.assertEqual(resp.status_code, 400) + + +if __name__ == '__main__': + unittest.main(argv=[sys.argv[0]], exit=True) diff --git a/tests/server/api/v5/test_test_suites.py b/tests/server/api/v5/test_test_suites.py new file mode 100644 index 000000000..0dab8df70 --- /dev/null +++ b/tests/server/api/v5/test_test_suites.py @@ -0,0 +1,776 @@ +# Tests for the v5 test-suites endpoints. +# +# RUN: rm -rf %t.instance %t.pg.log +# RUN: %{utils}/with_postgres.sh %t.pg.log \ +# RUN: %{utils}/with_temporary_instance.py %t.instance \ +# RUN: -- python %s %t.instance +# END. + +import sys +import os +import unittest +from unittest.mock import patch + +import lnt.server.db.testsuitedb + +sys.path.insert(0, os.path.dirname(__file__)) +from v5_test_helpers import ( + create_app, create_client, admin_headers, make_scoped_headers, +) + + +MINIMAL_SUITE = { + 'format_version': '2', + 'name': 'newsuite', + 'machine_fields': [{'name': 'hostname'}], + 'run_fields': [ + {'name': 'llvm_project_revision', 'order': True}, + ], + 'metrics': [ + {'name': 'compile_time', 'type': 'Real', 'bigger_is_better': False}, + ], +} + + +class TestListTestSuites(unittest.TestCase): + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_list_returns_200(self): + resp = self.client.get('/api/v5/test-suites/') + self.assertEqual(resp.status_code, 200) + + def test_list_contains_nts(self): + resp = self.client.get('/api/v5/test-suites/') + data = resp.get_json() + self.assertIn('items', data) + names = [item['name'] for item in data['items']] + self.assertIn('nts', names) + + def test_list_items_have_name_schema_links(self): + resp = self.client.get('/api/v5/test-suites/') + data = resp.get_json() + for item in data['items']: + self.assertIn('name', item) + self.assertIn('schema', item) + self.assertIn('links', item) + + def test_list_no_auth_required(self): + resp = self.client.get('/api/v5/test-suites/') + self.assertEqual(resp.status_code, 200) + + def test_list_unknown_params_returns_400(self): + resp = self.client.get('/api/v5/test-suites/?bogus=1') + self.assertEqual(resp.status_code, 400) + data = resp.get_json() + self.assertIn('bogus', data['error']['message']) + + +class TestGetTestSuite(unittest.TestCase): + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_get_nts_returns_200(self): + resp = self.client.get('/api/v5/test-suites/nts') + self.assertEqual(resp.status_code, 200) + + def test_get_nts_has_schema_and_links(self): + resp = self.client.get('/api/v5/test-suites/nts') + data = resp.get_json() + self.assertIn('schema', data) + self.assertIn('links', data) + self.assertEqual(data['name'], 'nts') + + def test_get_nts_schema_has_name(self): + resp = self.client.get('/api/v5/test-suites/nts') + data = resp.get_json() + self.assertEqual(data['schema']['name'], 'nts') + + def test_get_nonexistent_returns_404(self): + resp = self.client.get('/api/v5/test-suites/nonexistent') + self.assertEqual(resp.status_code, 404) + + def test_get_unknown_params_returns_400(self): + resp = self.client.get('/api/v5/test-suites/nts?bogus=1') + self.assertEqual(resp.status_code, 400) + + +class TestCreateTestSuite(unittest.TestCase): + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + cls._manage_headers = make_scoped_headers(cls.app, 'manage') + + def _create_suite(self, payload=None, headers=None): + if payload is None: + payload = dict(MINIMAL_SUITE) + if headers is None: + headers = self._manage_headers + return self.client.post( + '/api/v5/test-suites/', + json=payload, + headers=headers, + ) + + def test_create_returns_201(self): + payload = dict(MINIMAL_SUITE, name='createsuite1') + resp = self._create_suite(payload) + self.assertEqual(resp.status_code, 201) + + def test_create_returns_location_header(self): + payload = dict(MINIMAL_SUITE, name='createsuite2') + resp = self._create_suite(payload) + self.assertEqual(resp.status_code, 201) + self.assertIn('Location', resp.headers) + self.assertIn('createsuite2', resp.headers['Location']) + + def test_created_suite_appears_in_list(self): + payload = dict(MINIMAL_SUITE, name='createsuite3') + resp = self._create_suite(payload) + self.assertEqual(resp.status_code, 201) + + list_resp = self.client.get('/api/v5/test-suites/') + data = list_resp.get_json() + names = [item['name'] for item in data['items']] + self.assertIn('createsuite3', names) + + def test_schema_roundtrips(self): + payload = dict(MINIMAL_SUITE, name='createsuite4') + resp = self._create_suite(payload) + self.assertEqual(resp.status_code, 201) + + detail_resp = self.client.get('/api/v5/test-suites/createsuite4') + self.assertEqual(detail_resp.status_code, 200) + data = detail_resp.get_json() + self.assertEqual(data['schema']['name'], 'createsuite4') + + def test_per_suite_endpoints_work(self): + payload = dict(MINIMAL_SUITE, name='createsuite5') + resp = self._create_suite(payload) + self.assertEqual(resp.status_code, 201) + + # Machines list should work + machines_resp = self.client.get('/api/v5/createsuite5/machines') + self.assertEqual(machines_resp.status_code, 200) + + def test_duplicate_returns_409(self): + payload = dict(MINIMAL_SUITE, name='createsuite6') + resp1 = self._create_suite(payload) + self.assertEqual(resp1.status_code, 201) + + resp2 = self._create_suite(payload) + self.assertEqual(resp2.status_code, 409) + + def test_invalid_name_returns_422(self): + payload = dict(MINIMAL_SUITE, name='123invalid') + resp = self._create_suite(payload) + self.assertIn(resp.status_code, (400, 422)) + + def test_name_with_spaces_returns_422(self): + payload = dict(MINIMAL_SUITE, name='has space') + resp = self._create_suite(payload) + self.assertIn(resp.status_code, (400, 422)) + + def test_missing_format_version_returns_422(self): + payload = dict(MINIMAL_SUITE, name='createsuite_nofv') + del payload['format_version'] + resp = self._create_suite(payload) + self.assertIn(resp.status_code, (400, 422)) + + def test_wrong_format_version_returns_422(self): + payload = dict(MINIMAL_SUITE, name='createsuite_wrongfv') + payload['format_version'] = '1' + resp = self._create_suite(payload) + self.assertIn(resp.status_code, (400, 422)) + + def test_no_order_field_returns_400(self): + payload = dict(MINIMAL_SUITE, name='createsuite_noorder') + payload['run_fields'] = [{'name': 'tag'}] # no order field + resp = self._create_suite(payload) + self.assertEqual(resp.status_code, 400) + + def test_invalid_metric_type_returns_400(self): + payload = dict(MINIMAL_SUITE, name='createsuite_badmetric') + payload['metrics'] = [{'name': 'x', 'type': 'BadType'}] + resp = self._create_suite(payload) + self.assertEqual(resp.status_code, 400) + + def test_empty_body_returns_422(self): + resp = self.client.post( + '/api/v5/test-suites/', + json={}, + headers=self._manage_headers, + ) + self.assertIn(resp.status_code, (400, 422)) + + +class TestCreateTestSuiteAuth(unittest.TestCase): + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_no_auth_returns_401(self): + payload = dict(MINIMAL_SUITE, name='authtest1') + resp = self.client.post('/api/v5/test-suites/', json=payload) + self.assertEqual(resp.status_code, 401) + + def test_read_scope_returns_403(self): + headers = make_scoped_headers(self.app, 'read') + payload = dict(MINIMAL_SUITE, name='authtest2') + resp = self.client.post( + '/api/v5/test-suites/', json=payload, headers=headers) + self.assertEqual(resp.status_code, 403) + + def test_submit_scope_returns_403(self): + headers = make_scoped_headers(self.app, 'submit') + payload = dict(MINIMAL_SUITE, name='authtest3') + resp = self.client.post( + '/api/v5/test-suites/', json=payload, headers=headers) + self.assertEqual(resp.status_code, 403) + + def test_triage_scope_returns_403(self): + headers = make_scoped_headers(self.app, 'triage') + payload = dict(MINIMAL_SUITE, name='authtest4') + resp = self.client.post( + '/api/v5/test-suites/', json=payload, headers=headers) + self.assertEqual(resp.status_code, 403) + + def test_manage_scope_returns_201(self): + headers = make_scoped_headers(self.app, 'manage') + payload = dict(MINIMAL_SUITE, name='authtest5') + resp = self.client.post( + '/api/v5/test-suites/', json=payload, headers=headers) + self.assertEqual(resp.status_code, 201) + + def test_admin_scope_returns_201(self): + payload = dict(MINIMAL_SUITE, name='authtest6') + resp = self.client.post( + '/api/v5/test-suites/', json=payload, + headers=admin_headers()) + self.assertEqual(resp.status_code, 201) + + +class TestDeleteTestSuite(unittest.TestCase): + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + cls._manage_headers = make_scoped_headers(cls.app, 'manage') + + def _create_and_return_name(self, name): + payload = dict(MINIMAL_SUITE, name=name) + resp = self.client.post( + '/api/v5/test-suites/', json=payload, + headers=self._manage_headers) + self.assertEqual(resp.status_code, 201) + return name + + def test_delete_with_confirm_returns_204(self): + name = self._create_and_return_name('deletesuite1') + resp = self.client.delete( + f'/api/v5/test-suites/{name}?confirm=true', + headers=self._manage_headers) + self.assertEqual(resp.status_code, 204) + + def test_delete_without_confirm_returns_400(self): + name = self._create_and_return_name('deletesuite2') + resp = self.client.delete( + f'/api/v5/test-suites/{name}', + headers=self._manage_headers) + self.assertEqual(resp.status_code, 400) + + def test_delete_with_confirm_false_returns_400(self): + name = self._create_and_return_name('deletesuite3') + resp = self.client.delete( + f'/api/v5/test-suites/{name}?confirm=false', + headers=self._manage_headers) + self.assertEqual(resp.status_code, 400) + + def test_delete_nonexistent_returns_404(self): + resp = self.client.delete( + '/api/v5/test-suites/nonexistent?confirm=true', + headers=self._manage_headers) + self.assertEqual(resp.status_code, 404) + + def test_deleted_suite_removed_from_list(self): + name = self._create_and_return_name('deletesuite4') + self.client.delete( + f'/api/v5/test-suites/{name}?confirm=true', + headers=self._manage_headers) + + list_resp = self.client.get('/api/v5/test-suites/') + data = list_resp.get_json() + names = [item['name'] for item in data['items']] + self.assertNotIn(name, names) + + def test_deleted_suite_per_suite_endpoints_404(self): + name = self._create_and_return_name('deletesuite5') + self.client.delete( + f'/api/v5/test-suites/{name}?confirm=true', + headers=self._manage_headers) + + resp = self.client.get(f'/api/v5/{name}/machines') + self.assertEqual(resp.status_code, 404) + + def test_recreate_after_delete(self): + name = self._create_and_return_name('deletesuite6') + self.client.delete( + f'/api/v5/test-suites/{name}?confirm=true', + headers=self._manage_headers) + + # Recreate with the same name + payload = dict(MINIMAL_SUITE, name=name) + resp = self.client.post( + '/api/v5/test-suites/', json=payload, + headers=self._manage_headers) + self.assertEqual(resp.status_code, 201) + + def test_delete_suite_with_data(self): + """Create a suite, add some data, then delete it.""" + name = self._create_and_return_name('deletesuite7') + + # Submit a machine to create some data via direct DB access + db = self.app.instance.get_database("default") + ts = db.testsuite[name] + session = db.make_session() + machine = ts.Machine('test-machine') + session.add(machine) + session.commit() + session.close() + + # Now delete + resp = self.client.delete( + f'/api/v5/test-suites/{name}?confirm=true', + headers=self._manage_headers) + self.assertEqual(resp.status_code, 204) + + +class TestDeleteTestSuiteErrorRecovery(unittest.TestCase): + """Test that the delete endpoint recovers from partial failures.""" + + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + cls._manage_headers = make_scoped_headers(cls.app, 'manage') + + def _create_and_return_name(self, name): + payload = dict(MINIMAL_SUITE, name=name) + resp = self.client.post( + '/api/v5/test-suites/', json=payload, + headers=self._manage_headers) + self.assertEqual(resp.status_code, 201) + return name + + def test_metadata_failure_preserves_suite(self): + """If metadata deletion fails, tables and in-memory state survive.""" + name = self._create_and_return_name('delfail1') + + # Verify suite exists + resp = self.client.get(f'/api/v5/test-suites/{name}') + self.assertEqual(resp.status_code, 200) + + db = self.app.instance.get_database("default") + + # Patch increment_registry_version to raise, simulating a failure + # during the metadata-commit step (step 1). Since the exception + # occurs inside the try block, the session is rolled back and the + # suite should remain fully intact. + with patch.object( + db, 'increment_registry_version', + side_effect=RuntimeError("simulated version increment failure"), + ): + resp = self.client.delete( + f'/api/v5/test-suites/{name}?confirm=true', + headers=self._manage_headers) + self.assertEqual(resp.status_code, 500) + + # The suite should still be accessible (metadata was rolled back) + self.assertIn(name, db.testsuite) + + # The suite should still appear in the list + list_resp = self.client.get('/api/v5/test-suites/') + data = list_resp.get_json() + names = [item['name'] for item in data['items']] + self.assertIn(name, names) + + # The suite's per-suite endpoints should still work + resp = self.client.get(f'/api/v5/{name}/machines') + self.assertEqual(resp.status_code, 200) + + # Now verify we can still successfully delete it (no corrupted state) + resp = self.client.delete( + f'/api/v5/test-suites/{name}?confirm=true', + headers=self._manage_headers) + self.assertEqual(resp.status_code, 204) + + def test_table_drop_failure_still_removes_suite(self): + """If table dropping fails after metadata commit, suite is still + removed from the in-memory dict (orphaned tables are harmless).""" + name = self._create_and_return_name('delfail2') + db = self.app.instance.get_database("default") + tsdb = db.testsuite[name] + + # Patch drop_all to fail + with patch.object( + tsdb.base.metadata, 'drop_all', + side_effect=RuntimeError("simulated table drop failure"), + ): + resp = self.client.delete( + f'/api/v5/test-suites/{name}?confirm=true', + headers=self._manage_headers) + # Should still succeed — table drop failure is non-fatal + self.assertEqual(resp.status_code, 204) + + # Suite should be gone from the in-memory dict + self.assertNotIn(name, db.testsuite) + + # Suite should be gone from the list endpoint + list_resp = self.client.get('/api/v5/test-suites/') + data = list_resp.get_json() + names = [item['name'] for item in data['items']] + self.assertNotIn(name, names) + + +class TestDeleteTestSuiteAuth(unittest.TestCase): + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + cls._manage_headers = make_scoped_headers(cls.app, 'manage') + # Create a suite to test against + payload = dict(MINIMAL_SUITE, name='delauth') + cls.client.post( + '/api/v5/test-suites/', json=payload, + headers=cls._manage_headers) + + def test_no_auth_returns_401(self): + resp = self.client.delete( + '/api/v5/test-suites/delauth?confirm=true') + self.assertEqual(resp.status_code, 401) + + def test_read_scope_returns_403(self): + headers = make_scoped_headers(self.app, 'read') + resp = self.client.delete( + '/api/v5/test-suites/delauth?confirm=true', headers=headers) + self.assertEqual(resp.status_code, 403) + + def test_submit_scope_returns_403(self): + headers = make_scoped_headers(self.app, 'submit') + resp = self.client.delete( + '/api/v5/test-suites/delauth?confirm=true', headers=headers) + self.assertEqual(resp.status_code, 403) + + def test_triage_scope_returns_403(self): + headers = make_scoped_headers(self.app, 'triage') + resp = self.client.delete( + '/api/v5/test-suites/delauth?confirm=true', headers=headers) + self.assertEqual(resp.status_code, 403) + + def test_manage_scope_returns_204(self): + # Create a fresh suite for this test + payload = dict(MINIMAL_SUITE, name='delauth_manage') + self.client.post( + '/api/v5/test-suites/', json=payload, + headers=self._manage_headers) + + resp = self.client.delete( + '/api/v5/test-suites/delauth_manage?confirm=true', + headers=self._manage_headers) + self.assertEqual(resp.status_code, 204) + + +class TestDiscoveryAfterCreate(unittest.TestCase): + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + cls._manage_headers = make_scoped_headers(cls.app, 'manage') + + def test_new_suite_appears_in_discovery(self): + payload = dict(MINIMAL_SUITE, name='discoversuite') + resp = self.client.post( + '/api/v5/test-suites/', json=payload, + headers=self._manage_headers) + self.assertEqual(resp.status_code, 201) + + disc_resp = self.client.get('/api/v5/') + data = disc_resp.get_json() + names = [s['name'] for s in data['test_suites']] + self.assertIn('discoversuite', names) + + +class TestUnknownParamsOnMutations(unittest.TestCase): + """Unknown query params on POST and DELETE should be rejected.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + cls._manage_headers = make_scoped_headers(cls.app, 'manage') + + def test_post_unknown_param_returns_400(self): + payload = dict(MINIMAL_SUITE, name='unknownparam_post') + resp = self.client.post( + '/api/v5/test-suites/?bogus=1', + json=payload, + headers=self._manage_headers) + self.assertEqual(resp.status_code, 400) + data = resp.get_json() + self.assertIn('bogus', data['error']['message']) + + def test_delete_unknown_param_returns_400(self): + # Create suite first + payload = dict(MINIMAL_SUITE, name='unknownparam_del') + self.client.post( + '/api/v5/test-suites/', json=payload, + headers=self._manage_headers) + + resp = self.client.delete( + '/api/v5/test-suites/unknownparam_del?confirm=true&bogus=1', + headers=self._manage_headers) + self.assertEqual(resp.status_code, 400) + data = resp.get_json() + self.assertIn('bogus', data['error']['message']) + + +class TestCreateRaceCondition(unittest.TestCase): + """Test the DB-level duplicate guard (race condition path).""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + cls._manage_headers = make_scoped_headers(cls.app, 'manage') + + def test_db_row_exists_but_not_in_memory_returns_409(self): + """If a TestSuite row exists in the DB but is not in the in-memory + cache, POST should still return 409 (race-condition guard).""" + # First create a suite normally so the DB row exists + payload = dict(MINIMAL_SUITE, name='racesuite') + resp = self.client.post( + '/api/v5/test-suites/', json=payload, + headers=self._manage_headers) + self.assertEqual(resp.status_code, 201) + + # Remove it from the in-memory cache only (simulating another + # worker that hasn't reloaded yet) + db = self.app.instance.get_database("default") + saved_tsdb = db.testsuite.pop('racesuite', None) + self.assertIsNotNone(saved_tsdb) + + try: + # POST should hit the DB-level check and return 409 + resp = self.client.post( + '/api/v5/test-suites/', json=payload, + headers=self._manage_headers) + self.assertEqual(resp.status_code, 409) + finally: + # Restore the in-memory entry to avoid side-effects + if saved_tsdb is not None: + db.testsuite['racesuite'] = saved_tsdb + db.testsuite = dict(sorted(db.testsuite.items())) + + +class TestCreateTestSuiteErrorRecovery(unittest.TestCase): + """Test that the create endpoint recovers from partial failures.""" + + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + cls._manage_headers = make_scoped_headers(cls.app, 'manage') + + def _create_suite(self, payload=None, headers=None): + if payload is None: + payload = dict(MINIMAL_SUITE) + if headers is None: + headers = self._manage_headers + return self.client.post( + '/api/v5/test-suites/', + json=payload, + headers=headers, + ) + + def test_table_creation_failure_rolls_back_metadata(self): + """If create_tables fails, metadata rows are rolled back and no + suite appears in the in-memory dict or the list endpoint.""" + name = 'createfail1' + payload = dict(MINIMAL_SUITE, name=name) + + db = self.app.instance.get_database("default") + + # Patch create_tables on TestSuiteDB instances to raise. + with patch.object( + lnt.server.db.testsuitedb.TestSuiteDB, 'create_tables', + side_effect=RuntimeError("simulated table creation failure"), + ): + resp = self._create_suite(payload) + self.assertIn(resp.status_code, (400, 500)) + + # Suite must NOT be in the in-memory dict. + self.assertNotIn(name, db.testsuite) + + # Suite must NOT appear in the list endpoint. + list_resp = self.client.get('/api/v5/test-suites/') + data = list_resp.get_json() + names = [item['name'] for item in data['items']] + self.assertNotIn(name, names) + + # Metadata rows must have been rolled back -- we can create the + # same suite successfully now. + resp = self._create_suite(payload) + self.assertEqual(resp.status_code, 201) + + def test_registry_version_failure_rolls_back_metadata(self): + """If increment_registry_version fails, metadata and tables are + cleaned up and the suite can be retried.""" + name = 'createfail2' + payload = dict(MINIMAL_SUITE, name=name) + + db = self.app.instance.get_database("default") + + with patch.object( + db, 'increment_registry_version', + side_effect=RuntimeError("simulated version increment failure"), + ): + resp = self._create_suite(payload) + self.assertIn(resp.status_code, (400, 500)) + + # Suite must NOT be in the in-memory dict. + self.assertNotIn(name, db.testsuite) + + # Suite must NOT appear in the list endpoint. + list_resp = self.client.get('/api/v5/test-suites/') + data = list_resp.get_json() + names = [item['name'] for item in data['items']] + self.assertNotIn(name, names) + + # The suite can be created successfully on retry. + resp = self._create_suite(payload) + self.assertEqual(resp.status_code, 201) + + def test_successful_create_still_works(self): + """Sanity check: normal creation still succeeds after the refactor.""" + name = 'createfail3' + payload = dict(MINIMAL_SUITE, name=name) + resp = self._create_suite(payload) + self.assertEqual(resp.status_code, 201) + + # Suite is in-memory and reachable via the API. + db = self.app.instance.get_database("default") + self.assertIn(name, db.testsuite) + + detail_resp = self.client.get(f'/api/v5/test-suites/{name}') + self.assertEqual(detail_resp.status_code, 200) + + # Per-suite endpoints work. + machines_resp = self.client.get(f'/api/v5/{name}/machines') + self.assertEqual(machines_resp.status_code, 200) + + +class TestRegistryVersionPropagation(unittest.TestCase): + """Test that the registry version mechanism detects changes.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + cls._manage_headers = make_scoped_headers(cls.app, 'manage') + + def test_version_increments_on_create(self): + """Creating a suite should increment the registry version.""" + from lnt.server.db.testsuite import TestSuiteRegistryVersion + + db = self.app.instance.get_database("default") + session = db.make_session() + row = session.query(TestSuiteRegistryVersion).first() + version_before = row.version if row else 0 + session.close() + + payload = dict(MINIMAL_SUITE, name='regversuite1') + resp = self.client.post( + '/api/v5/test-suites/', json=payload, + headers=self._manage_headers) + self.assertEqual(resp.status_code, 201) + + session = db.make_session() + row = session.query(TestSuiteRegistryVersion).first() + version_after = row.version + session.close() + + self.assertGreater(version_after, version_before) + + def test_version_increments_on_delete(self): + """Deleting a suite should increment the registry version.""" + from lnt.server.db.testsuite import TestSuiteRegistryVersion + + # Create + payload = dict(MINIMAL_SUITE, name='regversuite2') + self.client.post( + '/api/v5/test-suites/', json=payload, + headers=self._manage_headers) + + db = self.app.instance.get_database("default") + session = db.make_session() + row = session.query(TestSuiteRegistryVersion).first() + version_before = row.version + session.close() + + # Delete + self.client.delete( + '/api/v5/test-suites/regversuite2?confirm=true', + headers=self._manage_headers) + + session = db.make_session() + row = session.query(TestSuiteRegistryVersion).first() + version_after = row.version + session.close() + + self.assertGreater(version_after, version_before) + + def test_stale_version_triggers_reload(self): + """Simulate another worker bumping the version; verify reload.""" + from lnt.server.db.testsuite import TestSuiteRegistryVersion + + db = self.app.instance.get_database("default") + suites_before = set(db.testsuite.keys()) + + # Artificially bump the DB version to simulate another worker + session = db.make_session() + row = session.query(TestSuiteRegistryVersion).first() + if row is not None: + row.version = row.version + 100 + session.commit() + bumped_version = row.version + session.close() + + # The next API request should detect the stale version and reload + resp = self.client.get('/api/v5/test-suites/') + self.assertEqual(resp.status_code, 200) + + # After reload, the cached version should match the DB + self.assertEqual(db._registry_version, bumped_version) + + # Suites should still be present (reload reconstructs them) + suites_after = set(db.testsuite.keys()) + self.assertTrue(suites_before.issubset(suites_after)) + + +if __name__ == '__main__': + unittest.main(argv=[sys.argv[0]], exit=True) diff --git a/tests/server/api/v5/test_tests.py b/tests/server/api/v5/test_tests.py new file mode 100644 index 000000000..1be3c0a72 --- /dev/null +++ b/tests/server/api/v5/test_tests.py @@ -0,0 +1,300 @@ +# Tests for the v5 test entity endpoints. +# +# RUN: rm -rf %t.instance %t.pg.log +# RUN: %{utils}/with_postgres.sh %t.pg.log \ +# RUN: %{utils}/with_temporary_instance.py %t.instance \ +# RUN: -- python %s %t.instance +# END. + +import sys +import os +import unittest +import uuid + +sys.path.insert(0, os.path.dirname(__file__)) +from v5_test_helpers import ( + create_app, create_client, create_test, collect_all_pages, +) + + +TS = 'nts' +PREFIX = f'/api/v5/{TS}' + + +def _get_ts_and_session(app): + """Helper to get a testsuite DB object and session.""" + db = app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + return ts, session + + +class TestTestList(unittest.TestCase): + """Tests for GET /api/v5/{ts}/tests.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_list_returns_200(self): + resp = self.client.get(PREFIX + '/tests') + self.assertEqual(resp.status_code, 200) + + def test_list_has_pagination_envelope(self): + resp = self.client.get(PREFIX + '/tests') + data = resp.get_json() + self.assertIn('items', data) + self.assertIn('cursor', data) + + def test_list_empty(self): + """List tests returns items array (may be empty if no tests exist).""" + resp = self.client.get(PREFIX + '/tests') + data = resp.get_json() + self.assertIsInstance(data['items'], list) + + def test_list_with_data(self): + """After creating a test, it appears in the list.""" + ts, session = _get_ts_and_session(self.app) + unique = uuid.uuid4().hex[:8] + name = f'list-test-{unique}' + create_test(session, ts, name=name) + session.commit() + session.close() + + resp = self.client.get( + PREFIX + f'/tests?name_contains={unique}') + data = resp.get_json() + names = [t['name'] for t in data['items']] + self.assertIn(name, names) + + def test_invalid_cursor_returns_400(self): + """An invalid cursor string should return 400.""" + resp = self.client.get( + PREFIX + '/tests?cursor=not-a-valid-cursor!!!') + self.assertEqual(resp.status_code, 400) + + +class TestTestDetail(unittest.TestCase): + """Tests for GET /api/v5/{ts}/tests/{test_name}.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_get_test_detail(self): + """Get test detail by name.""" + ts, session = _get_ts_and_session(self.app) + unique = uuid.uuid4().hex[:8] + name = f'detail-test-{unique}' + create_test(session, ts, name=name) + session.commit() + session.close() + + resp = self.client.get(PREFIX + f'/tests/{name}') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertEqual(data['name'], name) + + def test_get_test_with_slashes(self): + """Test names with slashes should work via path converter.""" + ts, session = _get_ts_and_session(self.app) + unique = uuid.uuid4().hex[:8] + name = f'suite/sub/{unique}/benchmark' + create_test(session, ts, name=name) + session.commit() + session.close() + + resp = self.client.get(PREFIX + f'/tests/{name}') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertEqual(data['name'], name) + + def test_get_nonexistent_404(self): + """Getting a nonexistent test should return 404.""" + resp = self.client.get( + PREFIX + '/tests/nonexistent-test-xyz-12345') + self.assertEqual(resp.status_code, 404) + + +class TestTestDetailETag(unittest.TestCase): + """ETag tests for GET /api/v5/{ts}/tests/{test_name}.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_etag_present_on_detail(self): + """Test detail response should include an ETag header.""" + ts, session = _get_ts_and_session(self.app) + unique = uuid.uuid4().hex[:8] + name = f'etag-present-{unique}' + create_test(session, ts, name=name) + session.commit() + session.close() + + resp = self.client.get(PREFIX + f'/tests/{name}') + self.assertEqual(resp.status_code, 200) + etag = resp.headers.get('ETag') + self.assertIsNotNone(etag) + self.assertTrue(etag.startswith('W/"')) + + def test_etag_304_on_match(self): + """Sending If-None-Match with the same ETag returns 304.""" + ts, session = _get_ts_and_session(self.app) + unique = uuid.uuid4().hex[:8] + name = f'etag-304-{unique}' + create_test(session, ts, name=name) + session.commit() + session.close() + + resp = self.client.get(PREFIX + f'/tests/{name}') + etag = resp.headers.get('ETag') + + resp2 = self.client.get( + PREFIX + f'/tests/{name}', + headers={'If-None-Match': etag}, + ) + self.assertEqual(resp2.status_code, 304) + + def test_etag_200_on_mismatch(self): + """Sending If-None-Match with a different ETag returns 200.""" + ts, session = _get_ts_and_session(self.app) + unique = uuid.uuid4().hex[:8] + name = f'etag-200-{unique}' + create_test(session, ts, name=name) + session.commit() + session.close() + + resp = self.client.get( + PREFIX + f'/tests/{name}', + headers={'If-None-Match': 'W/"stale-etag-value"'}, + ) + self.assertEqual(resp.status_code, 200) + self.assertIsNotNone(resp.get_json()) + + +class TestTestFilters(unittest.TestCase): + """Test filtering for GET /api/v5/{ts}/tests.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_filter_name_contains(self): + """Filter tests by name_contains.""" + ts, session = _get_ts_and_session(self.app) + unique = uuid.uuid4().hex[:8] + name = f'contains-test-{unique}' + create_test(session, ts, name=name) + session.commit() + session.close() + + resp = self.client.get( + PREFIX + f'/tests?name_contains={unique}') + data = resp.get_json() + self.assertGreater(len(data['items']), 0) + for t in data['items']: + self.assertIn(unique, t['name']) + + def test_filter_name_prefix(self): + """Filter tests by name_prefix.""" + ts, session = _get_ts_and_session(self.app) + unique = uuid.uuid4().hex[:8] + prefix = f'prefix-{unique}' + name = f'{prefix}-test' + create_test(session, ts, name=name) + session.commit() + session.close() + + resp = self.client.get( + PREFIX + f'/tests?name_prefix={prefix}') + data = resp.get_json() + self.assertGreater(len(data['items']), 0) + for t in data['items']: + self.assertTrue(t['name'].startswith(prefix)) + + def test_filter_no_match(self): + """Filter that matches nothing returns empty list.""" + resp = self.client.get( + PREFIX + '/tests?name_contains=zzzz_no_match_xyz_9999') + data = resp.get_json() + self.assertEqual(len(data['items']), 0) + + def test_filter_sql_wildcards_escaped(self): + """Ensure % and _ in filter values are escaped (no SQL injection).""" + ts, session = _get_ts_and_session(self.app) + unique = uuid.uuid4().hex[:8] + # Create a test with a literal underscore + name = f'esc_test_{unique}' + create_test(session, ts, name=name) + session.commit() + session.close() + + # Search for literal underscore -- should NOT match arbitrary chars + resp = self.client.get( + PREFIX + f'/tests?name_contains=esc_test_{unique}') + data = resp.get_json() + self.assertGreater(len(data['items']), 0) + + +class TestTestPagination(unittest.TestCase): + """Exhaustive cursor pagination tests for GET /api/v5/{ts}/tests.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + cls._prefix = f'pag-{uuid.uuid4().hex[:8]}' + ts, session = _get_ts_and_session(cls.app) + for i in range(5): + create_test(session, ts, name=f'{cls._prefix}-test-{i}') + session.commit() + session.close() + + def _collect_all_pages(self): + url = PREFIX + f'/tests?name_prefix={self._prefix}&limit=2' + return collect_all_pages(self, self.client, url) + + def test_pagination_collects_all_items(self): + """Paginating through all pages collects all 5 tests.""" + all_items = self._collect_all_pages() + self.assertEqual(len(all_items), 5) + + def test_no_duplicate_items_across_pages(self): + """No duplicate test names across pages.""" + all_items = self._collect_all_pages() + names = [item['name'] for item in all_items] + self.assertEqual(len(names), len(set(names))) + + +class TestTestUnknownParams(unittest.TestCase): + """Test that unknown query parameters are rejected with 400.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_tests_list_unknown_param_returns_400(self): + resp = self.client.get(PREFIX + '/tests?bogus=1') + self.assertEqual(resp.status_code, 400) + data = resp.get_json() + self.assertIn('bogus', data['error']['message']) + + def test_test_detail_unknown_param_returns_400(self): + ts, session = _get_ts_and_session(self.app) + unique = uuid.uuid4().hex[:8] + name = f'unk-det-{unique}' + create_test(session, ts, name=name) + session.commit() + session.close() + resp = self.client.get(PREFIX + f'/tests/{name}?bogus=1') + self.assertEqual(resp.status_code, 400) + + +if __name__ == '__main__': + unittest.main(argv=[sys.argv[0]], exit=True) diff --git a/tests/server/api/v5/v5_test_helpers.py b/tests/server/api/v5/v5_test_helpers.py new file mode 100644 index 000000000..a25ae073d --- /dev/null +++ b/tests/server/api/v5/v5_test_helpers.py @@ -0,0 +1,189 @@ +"""Shared helpers for v5 API tests. + +Provides: +- ``create_app`` -- Create a Flask app from an instance path +- ``create_client`` -- Return a Flask test client +- Auth helpers for creating API keys and headers +- Data creation helpers (machine, order, run, test, sample, etc.) +""" + +import datetime +import hashlib +import uuid + +import lnt.server.ui.app + + +# --------------------------------------------------------------------------- +# Application & client helpers +# --------------------------------------------------------------------------- + +def create_app(instance_path): + """Create a Flask app backed by the given LNT instance.""" + app = lnt.server.ui.app.App.create_standalone(instance_path) + app.testing = True + return app + + +def create_client(app): + """Return a Flask test client for *app*.""" + return app.test_client() + + +# --------------------------------------------------------------------------- +# Auth helpers +# --------------------------------------------------------------------------- + +def make_api_key(session, name, scope, raw_token): + """Insert an APIKey row and return the Bearer header dict.""" + from lnt.server.api.v5.auth import APIKey + key_hash = hashlib.sha256(raw_token.encode('utf-8')).hexdigest() + api_key = APIKey( + name=name, + key_prefix=raw_token[:8], + key_hash=key_hash, + scope=scope, + created_at=datetime.datetime.utcnow(), + is_active=True, + ) + session.add(api_key) + session.commit() + return {'Authorization': f'Bearer {raw_token}'} + + +def admin_headers(): + """Auth headers using the bootstrap api_auth_token (admin scope).""" + return {'Authorization': 'Bearer test_token'} + + +def make_scoped_headers(app, scope_name): + """Create an API key with the given scope and return Bearer headers.""" + db = app.instance.get_database("default") + session = db.make_session() + token = f'{scope_name}token_{uuid.uuid4().hex[:20]}' + headers = make_api_key(session, f'test-{scope_name}', scope_name, token) + session.close() + return headers + + +# --------------------------------------------------------------------------- +# Data creation helpers +# --------------------------------------------------------------------------- + +def create_machine(session, ts, name='test-machine', **info_fields): + """Create a Machine and return it.""" + machine = ts.Machine(name) + declared = {f.name for f in ts.machine_fields} + params = {} + for key, value in info_fields.items(): + if key in declared: + setattr(machine, key, value) + else: + params[key] = value + if params: + machine.parameters = params + session.add(machine) + session.flush() + return machine + + +def create_order(session, ts, revision='1'): + """Create an Order and return it.""" + order = ts.Order() + order.set_field(ts.order_fields[0], revision) + session.add(order) + session.flush() + return order + + +def create_run(session, ts, machine, order, + start_time=None, end_time=None): + """Create a Run and return it.""" + if start_time is None: + start_time = datetime.datetime(2024, 1, 1, 12, 0, 0) + if end_time is None: + end_time = datetime.datetime(2024, 1, 1, 12, 30, 0) + run = ts.Run(None, machine, order, start_time, end_time) + run.uuid = str(uuid.uuid4()) + run.parameters = {} + session.add(run) + session.flush() + return run + + +def create_test(session, ts, name='test.suite/benchmark'): + """Create a Test and return it.""" + test = ts.Test(name) + session.add(test) + session.flush() + return test + + +def create_sample(session, ts, run, test, **field_values): + """Create a Sample and return it.""" + sample = ts.Sample(run, test, **field_values) + session.add(sample) + session.flush() + return sample + + +def create_fieldchange(session, ts, start_order, end_order, machine, test, + field, old_value=1.0, new_value=2.0, run=None): + """Create a FieldChange and return it.""" + fc = ts.FieldChange(start_order=start_order, end_order=end_order, + machine=machine, test=test, field_id=field.id) + fc.uuid = str(uuid.uuid4()) + fc.old_value = old_value + fc.new_value = new_value + if run: + fc.run = run + session.add(fc) + session.flush() + return fc + + +def create_regression(session, ts, title='Test Regression', + state=0, field_changes=None): + """Create a Regression (optionally with indicators) and return it.""" + regression = ts.Regression(title, '', state) + regression.uuid = str(uuid.uuid4()) + session.add(regression) + session.flush() + + if field_changes: + for fc in field_changes: + ri = ts.RegressionIndicator(regression, fc) + session.add(ri) + session.flush() + + return regression + + +# --------------------------------------------------------------------------- +# Pagination helpers +# --------------------------------------------------------------------------- + +def collect_all_pages(test_case, client, url, page_limit=20): + """Traverse all pages of a cursor-paginated endpoint. + + Returns a list of all items collected across every page. Fails the + *test_case* if more than *page_limit* pages are fetched (infinite-loop + guard). + """ + all_items = [] + resp = client.get(url) + test_case.assertEqual(resp.status_code, 200) + data = resp.get_json() + all_items.extend(data['items']) + cursor = data['cursor']['next'] + pages = 1 + while cursor: + resp = client.get(url + f'&cursor={cursor}') + test_case.assertEqual(resp.status_code, 200) + data = resp.get_json() + all_items.extend(data['items']) + cursor = data['cursor']['next'] + pages += 1 + if pages > page_limit: + test_case.fail("Too many pages; possible infinite loop") + return all_items diff --git a/tests/server/db/CreateV4TestSuiteInstance.py b/tests/server/db/CreateV4TestSuiteInstance.py index cda3e2de1..5db7c1cb6 100644 --- a/tests/server/db/CreateV4TestSuiteInstance.py +++ b/tests/server/db/CreateV4TestSuiteInstance.py @@ -7,6 +7,7 @@ import datetime import sys +import uuid import lnt.server.instance from lnt.server.db.fieldchange import RegressionState @@ -56,11 +57,13 @@ session.add(sample) field_change = ts_db.FieldChange(order, order2, machine, test, list(sample.get_primary_fields())[0].id) +field_change.uuid = str(uuid.uuid4()) session.add(field_change) field_change2 = ts_db.FieldChange(order2, order3, machine, test, list(sample.get_primary_fields())[1].id) +field_change2.uuid = str(uuid.uuid4()) session.add(field_change2) TEST_TITLE = "Some regression title" diff --git a/tests/server/ui/change_processing.py b/tests/server/ui/change_processing.py index 7213b7027..3a8d66f0a 100644 --- a/tests/server/ui/change_processing.py +++ b/tests/server/ui/change_processing.py @@ -7,6 +7,7 @@ import subprocess import sys import unittest +import uuid from sqlalchemy import or_ from sqlalchemy.orm import joinedload @@ -87,6 +88,7 @@ def setUp(self): machine, test, a_field.id) + field_change.uuid = str(uuid.uuid4()) field_change.run = run session.add(field_change) @@ -95,19 +97,21 @@ def setUp(self): machine2, test, a_field.id) + fc_mach2.uuid = str(uuid.uuid4()) fc_mach2.run = run2 session.add(fc_mach2) field_change2 = self.field_change2 = ts_db.FieldChange(order1235, order1236, machine, test, a_field.id) - + field_change2.uuid = str(uuid.uuid4()) field_change2.run = run session.add(field_change2) field_change3 = self.field_change3 = ts_db.FieldChange(order1237, order1238, machine, test, a_field.id) + field_change3.uuid = str(uuid.uuid4()) session.add(field_change3) regression = self.regression = ts_db.Regression("Regression of 1 benchmarks:", "PR1234", @@ -170,6 +174,7 @@ def test_change_grouping_criteria(self): self.machine2, self.test2, self.a_field.id) + field_change7.uuid = str(uuid.uuid4()) session.add(field_change7) active_indicators = session.query(ts_db.FieldChange) \ @@ -192,6 +197,7 @@ def test_change_grouping_criteria(self): self.machine2, self.test, self.a_field.id) + field_change4.uuid = str(uuid.uuid4()) # Check a regression matches if all fields match. ret, _ = identify_related_changes(session, ts_db, field_change4, active_indicators) @@ -202,6 +208,7 @@ def test_change_grouping_criteria(self): self.machine, self.test2, self.a_field.id) + field_change5.uuid = str(uuid.uuid4()) # Check a regression matches if all fields match. ret, _ = identify_related_changes(session, ts_db, field_change5, active_indicators) @@ -211,6 +218,7 @@ def test_change_grouping_criteria(self): self.machine, self.test, self.a_field2.id) + field_change6.uuid = str(uuid.uuid4()) # Check a regression matches if all fields match. ret, _ = identify_related_changes(session, ts_db, field_change6, active_indicators) @@ -265,6 +273,59 @@ def test_run_deletion(self): self.assertEqual(len(ri_ids_new), 0) + def test_fieldchanges_have_uuids(self): + """Verify that all FieldChanges created in setUp have UUIDs set. + + This is a regression test for a bug where FieldChanges created through + the v4 UI path (manual regression creation) did not get UUIDs assigned, + making them invisible to the v5 API. + """ + session = self.session + ts_db = self.ts_db + + # All FieldChanges in the database should have a UUID. + all_fcs = session.query(ts_db.FieldChange).all() + self.assertGreater(len(all_fcs), 0, + "Expected at least one FieldChange in the DB") + for fc in all_fcs: + self.assertIsNotNone(fc.uuid, + "FieldChange id=%s is missing a UUID" % fc.id) + self.assertNotEqual(fc.uuid, '', + "FieldChange id=%s has an empty UUID" % fc.id) + + def test_manual_fieldchange_creation_gets_uuid(self): + """Simulate the v4 manual regression creation path and verify UUIDs. + + This mirrors what regression_views.v4_make_regression does when + creating a FieldChange that doesn't already exist. + """ + session = self.session + ts_db = self.ts_db + + # Create a new FieldChange the same way regression_views.py does. + new_fc = ts_db.FieldChange( + start_order=self.order1234, + end_order=self.order1238, + machine=self.machine, + test=self.test2, + field_id=self.a_field.id) + new_fc.uuid = str(uuid.uuid4()) + session.add(new_fc) + session.flush() + + # Verify the UUID is set and valid. + self.assertIsNotNone(new_fc.uuid) + self.assertNotEqual(new_fc.uuid, '') + + # Verify it's a valid UUID string. + parsed = uuid.UUID(new_fc.uuid) + self.assertEqual(str(parsed), new_fc.uuid) + + # Verify it persists after commit. + session.commit() + reloaded = session.query(ts_db.FieldChange).get(new_fc.id) + self.assertEqual(reloaded.uuid, new_fc.uuid) + if __name__ == '__main__': unittest.main() From c4ec442fd0027eee5f210cfc8ddeba060b22944d Mon Sep 17 00:00:00 2001 From: Louis Dionne Date: Fri, 3 Apr 2026 11:03:57 -0400 Subject: [PATCH 002/143] [UI] v5 UI Design and implementation Assisted-by: Claude Code --- .github/workflows/tox.yaml | 6 + .gitignore | 4 + MANIFEST.in | 1 + docs/design/v5-ui.md | 402 +++ docs/developer_guide.rst | 4 +- docs/v5-ui-implementation-plan.md | 2165 +++++++++++++++++ lnt/server/ui/app.py | 4 + lnt/server/ui/templates/layout.html | 70 +- lnt/server/ui/v5/__init__.py | 20 + lnt/server/ui/v5/frontend/package-lock.json | 2080 ++++++++++++++++ lnt/server/ui/v5/frontend/package.json | 14 + .../ui/v5/frontend/src/__tests__/api.test.ts | 1013 ++++++++ .../v5/frontend/src/__tests__/chart.test.ts | 227 ++ .../frontend/src/__tests__/combobox.test.ts | 182 ++ .../frontend/src/__tests__/comparison.test.ts | 567 +++++ .../frontend/src/__tests__/data-table.test.ts | 159 ++ .../src/__tests__/legend-table.test.ts | 167 ++ .../src/__tests__/machine-combobox.test.ts | 125 + .../src/__tests__/metric-selector.test.ts | 117 + .../ui/v5/frontend/src/__tests__/nav.test.ts | 151 ++ .../src/__tests__/order-search.test.ts | 206 ++ .../src/__tests__/pages/admin.test.ts | 262 ++ .../src/__tests__/pages/compare.test.ts | 101 + .../src/__tests__/pages/graph.test.ts | 402 +++ .../frontend/src/__tests__/pagination.test.ts | 92 + .../v5/frontend/src/__tests__/router.test.ts | 184 ++ .../frontend/src/__tests__/selection.test.ts | 69 + .../v5/frontend/src/__tests__/state.test.ts | 493 ++++ .../v5/frontend/src/__tests__/table.test.ts | 503 ++++ .../src/__tests__/time-series-chart.test.ts | 642 +++++ .../v5/frontend/src/__tests__/utils.test.ts | 337 +++ lnt/server/ui/v5/frontend/src/api.ts | 412 ++++ lnt/server/ui/v5/frontend/src/chart.ts | 277 +++ lnt/server/ui/v5/frontend/src/combobox.ts | 324 +++ lnt/server/ui/v5/frontend/src/comparison.ts | 182 ++ .../v5/frontend/src/components/data-table.ts | 144 ++ .../frontend/src/components/delete-confirm.ts | 91 + .../frontend/src/components/legend-table.ts | 161 ++ .../src/components/machine-combobox.ts | 158 ++ .../src/components/metric-selector.ts | 49 + .../ui/v5/frontend/src/components/nav.ts | 205 ++ .../frontend/src/components/order-search.ts | 229 ++ .../v5/frontend/src/components/pagination.ts | 40 + .../src/components/time-series-chart.ts | 466 ++++ lnt/server/ui/v5/frontend/src/events.ts | 21 + lnt/server/ui/v5/frontend/src/main.ts | 75 + lnt/server/ui/v5/frontend/src/pages/admin.ts | 536 ++++ .../ui/v5/frontend/src/pages/compare.ts | 289 +++ .../ui/v5/frontend/src/pages/dashboard.ts | 114 + .../frontend/src/pages/field-change-triage.ts | 13 + lnt/server/ui/v5/frontend/src/pages/graph.ts | 1019 ++++++++ .../v5/frontend/src/pages/machine-detail.ts | 131 + .../ui/v5/frontend/src/pages/machine-list.ts | 106 + .../ui/v5/frontend/src/pages/order-detail.ts | 181 ++ .../frontend/src/pages/regression-detail.ts | 13 + .../v5/frontend/src/pages/regression-list.ts | 13 + .../ui/v5/frontend/src/pages/run-detail.ts | 193 ++ lnt/server/ui/v5/frontend/src/router.ts | 172 ++ lnt/server/ui/v5/frontend/src/selection.ts | 328 +++ lnt/server/ui/v5/frontend/src/state.ts | 150 ++ lnt/server/ui/v5/frontend/src/style.css | 1131 +++++++++ lnt/server/ui/v5/frontend/src/table.ts | 295 +++ lnt/server/ui/v5/frontend/src/types.ts | 170 ++ lnt/server/ui/v5/frontend/src/utils.ts | 127 + lnt/server/ui/v5/frontend/tsconfig.json | 14 + lnt/server/ui/v5/frontend/vite.config.ts | 25 + lnt/server/ui/v5/templates/v5_app.html | 20 + lnt/server/ui/v5/views.py | 42 + pyproject.toml | 18 +- tests/server/ui/v5/test_compare.py | 42 + tests/server/ui/v5/test_spa_shell.py | 171 ++ 71 files changed, 18881 insertions(+), 35 deletions(-) create mode 100644 docs/design/v5-ui.md create mode 100644 docs/v5-ui-implementation-plan.md create mode 100644 lnt/server/ui/v5/__init__.py create mode 100644 lnt/server/ui/v5/frontend/package-lock.json create mode 100644 lnt/server/ui/v5/frontend/package.json create mode 100644 lnt/server/ui/v5/frontend/src/__tests__/api.test.ts create mode 100644 lnt/server/ui/v5/frontend/src/__tests__/chart.test.ts create mode 100644 lnt/server/ui/v5/frontend/src/__tests__/combobox.test.ts create mode 100644 lnt/server/ui/v5/frontend/src/__tests__/comparison.test.ts create mode 100644 lnt/server/ui/v5/frontend/src/__tests__/data-table.test.ts create mode 100644 lnt/server/ui/v5/frontend/src/__tests__/legend-table.test.ts create mode 100644 lnt/server/ui/v5/frontend/src/__tests__/machine-combobox.test.ts create mode 100644 lnt/server/ui/v5/frontend/src/__tests__/metric-selector.test.ts create mode 100644 lnt/server/ui/v5/frontend/src/__tests__/nav.test.ts create mode 100644 lnt/server/ui/v5/frontend/src/__tests__/order-search.test.ts create mode 100644 lnt/server/ui/v5/frontend/src/__tests__/pages/admin.test.ts create mode 100644 lnt/server/ui/v5/frontend/src/__tests__/pages/compare.test.ts create mode 100644 lnt/server/ui/v5/frontend/src/__tests__/pages/graph.test.ts create mode 100644 lnt/server/ui/v5/frontend/src/__tests__/pagination.test.ts create mode 100644 lnt/server/ui/v5/frontend/src/__tests__/router.test.ts create mode 100644 lnt/server/ui/v5/frontend/src/__tests__/selection.test.ts create mode 100644 lnt/server/ui/v5/frontend/src/__tests__/state.test.ts create mode 100644 lnt/server/ui/v5/frontend/src/__tests__/table.test.ts create mode 100644 lnt/server/ui/v5/frontend/src/__tests__/time-series-chart.test.ts create mode 100644 lnt/server/ui/v5/frontend/src/__tests__/utils.test.ts create mode 100644 lnt/server/ui/v5/frontend/src/api.ts create mode 100644 lnt/server/ui/v5/frontend/src/chart.ts create mode 100644 lnt/server/ui/v5/frontend/src/combobox.ts create mode 100644 lnt/server/ui/v5/frontend/src/comparison.ts create mode 100644 lnt/server/ui/v5/frontend/src/components/data-table.ts create mode 100644 lnt/server/ui/v5/frontend/src/components/delete-confirm.ts create mode 100644 lnt/server/ui/v5/frontend/src/components/legend-table.ts create mode 100644 lnt/server/ui/v5/frontend/src/components/machine-combobox.ts create mode 100644 lnt/server/ui/v5/frontend/src/components/metric-selector.ts create mode 100644 lnt/server/ui/v5/frontend/src/components/nav.ts create mode 100644 lnt/server/ui/v5/frontend/src/components/order-search.ts create mode 100644 lnt/server/ui/v5/frontend/src/components/pagination.ts create mode 100644 lnt/server/ui/v5/frontend/src/components/time-series-chart.ts create mode 100644 lnt/server/ui/v5/frontend/src/events.ts create mode 100644 lnt/server/ui/v5/frontend/src/main.ts create mode 100644 lnt/server/ui/v5/frontend/src/pages/admin.ts create mode 100644 lnt/server/ui/v5/frontend/src/pages/compare.ts create mode 100644 lnt/server/ui/v5/frontend/src/pages/dashboard.ts create mode 100644 lnt/server/ui/v5/frontend/src/pages/field-change-triage.ts create mode 100644 lnt/server/ui/v5/frontend/src/pages/graph.ts create mode 100644 lnt/server/ui/v5/frontend/src/pages/machine-detail.ts create mode 100644 lnt/server/ui/v5/frontend/src/pages/machine-list.ts create mode 100644 lnt/server/ui/v5/frontend/src/pages/order-detail.ts create mode 100644 lnt/server/ui/v5/frontend/src/pages/regression-detail.ts create mode 100644 lnt/server/ui/v5/frontend/src/pages/regression-list.ts create mode 100644 lnt/server/ui/v5/frontend/src/pages/run-detail.ts create mode 100644 lnt/server/ui/v5/frontend/src/router.ts create mode 100644 lnt/server/ui/v5/frontend/src/selection.ts create mode 100644 lnt/server/ui/v5/frontend/src/state.ts create mode 100644 lnt/server/ui/v5/frontend/src/style.css create mode 100644 lnt/server/ui/v5/frontend/src/table.ts create mode 100644 lnt/server/ui/v5/frontend/src/types.ts create mode 100644 lnt/server/ui/v5/frontend/src/utils.ts create mode 100644 lnt/server/ui/v5/frontend/tsconfig.json create mode 100644 lnt/server/ui/v5/frontend/vite.config.ts create mode 100644 lnt/server/ui/v5/templates/v5_app.html create mode 100644 lnt/server/ui/v5/views.py create mode 100644 tests/server/ui/v5/test_compare.py create mode 100644 tests/server/ui/v5/test_spa_shell.py diff --git a/.github/workflows/tox.yaml b/.github/workflows/tox.yaml index 0d1c0a229..37c943e36 100644 --- a/.github/workflows/tox.yaml +++ b/.github/workflows/tox.yaml @@ -25,6 +25,10 @@ jobs: uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0 with: python-version: ${{ matrix.python-version }} + - name: Set up Node.js + uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0 + with: + node-version: '22' - name: Install dependencies run: | python -m pip install --upgrade pip @@ -37,3 +41,5 @@ jobs: run: tox -e mypy - name: Tox py3 run: tox -e py3 + - name: Tox js + run: tox -e js diff --git a/.gitignore b/.gitignore index efa0c2187..a56b24a79 100644 --- a/.gitignore +++ b/.gitignore @@ -10,3 +10,7 @@ lnt/server/ui/static/docs test_run_tmp tests/**/Output venv +lnt/server/ui/v5/frontend/node_modules/ +lnt/server/ui/v5/static/v5/v5.js +lnt/server/ui/v5/static/v5/v5.js.map +lnt/server/ui/v5/static/v5/v5.css diff --git a/MANIFEST.in b/MANIFEST.in index 6f331465f..824b35d2e 100644 --- a/MANIFEST.in +++ b/MANIFEST.in @@ -4,6 +4,7 @@ recursive-include docs * recursive-include tests * recursive-include examples * recursive-include lnt/server/ui/static *.css *.js *.html *.ico *.txt +recursive-include lnt/server/ui/v5/static *.css *.js *.map recursive-include lnt/server/ui/templates *.html recursive-include lnt/server/db/migrations * include lnt/server/ui/static/flot/Makefile diff --git a/docs/design/v5-ui.md b/docs/design/v5-ui.md new file mode 100644 index 000000000..e0cf79668 --- /dev/null +++ b/docs/design/v5-ui.md @@ -0,0 +1,402 @@ +# v5 Web UI Redesign — High-Level Plan + +## Context + +LNT's current web UI is built on v4 Flask/Jinja2 server-rendered pages with jQuery 1.7 and Bootstrap 2. It works but feels dated. The v5 REST API is now complete and a single v5 page already exists (the Compare SPA). This plan designs a complete new UI built exclusively on the v5 API. + +The v4 UI stays around as-is. The only integration point is a toggle link in each UI's navbar to switch between v4 and v5. + +## Architecture: Single-Page Application + +**One SPA with client-side routing**, extending the pattern proven by the existing Compare page. + +- **Framework**: Vanilla TypeScript (no React/Vue) — matches the existing Compare SPA +- **Build**: Vite, single IIFE bundle (`v5.js` + `v5.css`) +- **Charts**: Plotly.js (loaded from CDN) +- **Routing**: Simple path-based client-side router using History API +- **State**: URL query params for shareable deep-links; localStorage for auth token + +**Design consistency**: All pages should share a consistent look and feel, using the v5 Compare page as the reference for UI patterns — comboboxes, metric selectors, table styling, progress/error feedback, color scheme, and layout spacing. Reuse the same components across pages rather than reinventing per-page. Pages with selection controls (dropdowns, filters, aggregation settings) wrap them in a shared controls panel — a lightly shaded box with a border — so the settings area is visually distinct from the page content. + +**Authentication**: The v5 API allows unauthenticated reads by default (configurable via `require_auth_for_reads` in `lnt.cfg`). All pages in the current scope are read-only, so no authentication is needed. The SPA navigation bar includes a Settings panel with a Bearer token input (stored in localStorage) for the Admin page and future write-capable pages (regression triage, etc.). + +**Why SPA over server-rendered pages:** +- Avoids full-page reloads (and re-downloading Plotly) when navigating +- Shared state (auth token, test suite context) lives naturally in the app +- The Compare page already proves vanilla TS + Vite works well +- All data comes from the v5 REST API — no server-side rendering needed + +### Flask Backend: One Catch-All Route + +The v5 API only supports the default DB, so v5 frontend routes do not include `db_` prefixes. + +```python +# lnt/server/ui/v5/views.py +@v5_frontend.route("/v5//") +@v5_frontend.route("/v5//") +def v5_app(testsuite_name, subpath=None): + ...renders v5_app.html shell... +``` + +The existing Compare page route (`v5_compare`) also needs to be updated to remove its `db_` variant. + +The shell template (`v5_app.html`) is a standalone HTML page (it does NOT extend `layout.html`) and mounts `
` with the SPA bundle. This avoids inheriting v4 CSS/JS (Bootstrap 2, jQuery, DataTables) and layout artifacts (fixed-navbar margins, sticky footer). + +### v4/v5 Toggle + +- In the v4 navbar (`layout.html`): add a "v5 UI" link pointing to `/v5/{ts}/` +- In the v5 SPA navbar: a "v4 UI" link pointing to `/v4/{ts}/recent_activity` + +--- + +## Page Hierarchy + +``` +/v5/{ts}/ Dashboard (landing page) +/v5/{ts}/machines Machine List +/v5/{ts}/machines/{name} Machine Detail +/v5/{ts}/runs/{uuid} Run Detail +/v5/{ts}/orders/{value} Order Detail +/v5/{ts}/graph?machine=...&test=... Graph (time series) +/v5/{ts}/compare Compare (existing SPA, absorbed) +/v5/{ts}/regressions?state=... Regression List +/v5/{ts}/regressions/{uuid} Regression Detail +/v5/{ts}/field-changes Field Change Triage +/v5/admin Admin (API keys, schemas — not test-suite specific) +``` + +### Navigation Bar + +``` +[LNT] [Suite: nts ▾] Dashboard Graph Compare Regressions Machines Admin [v4 UI] [Settings] +``` + +--- + +## Page Details + +### 1. Dashboard — `/v5/{ts}/` + +The landing page. Order-centric view answering "what happened with recent commits?" + +| Section | Shows | API Calls | +|---------|-------|-----------| +| Recent Orders | Table of recent orders with two columns: order value with tag suffix when set (e.g. "abc123 (release-18)"), linked to Order Detail; and latest run timestamp, linked to Run Detail. | `GET runs?sort=-start_time&limit=...` (derive orders from runs), then `GET orders/{value}` per unique order to fetch tags | + +**Links out**: Order Detail, Run Detail. + +### 2. Machine List — `/v5/{ts}/machines` + +Searchable/filterable table of all machines. + +- Search by name (substring or prefix) +- Columns: name, key info fields +- API: `GET machines?name_contains={filter}` +- **Links out**: Machine Detail + +### 3. Machine Detail — `/v5/{ts}/machines/{name}` + +Deep dive into a single machine. Machine names are guaranteed unique. + +| Section | Shows | API Calls | +|---------|-------|-----------| +| Metadata | Machine info key-value pairs | `GET machines/{name}` | +| Run History | Paginated table of runs (newest first) | `GET machines/{name}/runs?sort=-start_time` | +| Delete | Delete button with confirmation prompt | `DELETE machines/{name}` (requires `manage` scope) | + +The delete section appears at the bottom. Clicking "Delete Machine" shows a confirmation prompt requiring the user to type the machine name. Deletion requires a valid API token with `manage` scope (set via the Settings panel in the nav bar). On success, navigates to the machine list. On auth failure (401/403), shows an error message reminding the user to set an API token with sufficient permissions. While the delete is in progress, a message reassures the user that deletion may take a while for machines with many runs. + +**Links out**: Run Detail, Order Detail, Graph (with machine pre-filled), Compare (with machine pre-selected). + +### 4. Run Detail — `/v5/{ts}/runs/{uuid}` + +All data from a single test execution. + +| Section | Shows | API Calls | +|---------|-------|-----------| +| Metadata | Machine, order, start/end time, parameters | `GET runs/{uuid}` | +| Metric Selector | Drop-down to choose which metric to display (like Compare page) | `GET test-suites/{ts}` (fields from `schema.metrics`) | +| Test Filter | Text input for substring matching on test names | (client-side) | +| Samples Table | All samples + selected metric value, sorted by test name by default | `GET runs/{uuid}/samples` | +| Delete | Delete button with confirmation prompt | `DELETE runs/{uuid}` (requires `manage` scope) | + +The metric selector drop-down controls which metric column is shown in the samples table, consistent with how the Compare page handles metric selection. + +Samples are loaded progressively — the table renders immediately with the first page and grows as more pages arrive, with a progress indicator showing the count. Multiple samples for the same test (repetitions) appear as separate rows. + +A "Compare with..." button navigates to the Compare page with this run's machine and order pre-selected on side A, leaving side B open for the user to fill in. + +The delete section appears at the bottom. Clicking "Delete Run" shows a confirmation prompt requiring the user to type the first 8 characters of the run UUID. Deletion requires a valid API token with `manage` scope. On success, navigates to the machine detail page. + +**Links out**: Machine Detail, Order Detail, Graph (test pre-filled), Profile, Compare (side A pre-selected). + +### 5. Order Detail — `/v5/{ts}/orders/{value}` + +The "what happened at this commit?" page. Key investigation page for developers. + +- Order field values displayed prominently +- **Tag display + editing**: Show the order's tag (if set) prominently next to the order field values (e.g., "Tag: release-18.1"). An inline edit button allows setting or clearing the tag. Editing requires an API token with `manage` scope (from Settings); show an auth error if the token is missing or insufficient. +- **Navigation**: Prev/Next buttons (using the API's `previous_order`/`next_order` from the order detail response) +- **Summary**: N runs across M machines +- **Machine filter**: Text input for substring matching on machine names, filters the runs table. The summary updates to reflect filtered counts (e.g., "5 of 12 runs across 2 of 8 machines"). +- **Runs table**: Columns: machine (link to Machine Detail), run UUID (link to Run Detail), start time +- API: `GET orders/{value}`, `PATCH orders/{value}` (tag editing), `GET runs?order={value}` +- **Links out**: Run Detail, Machine Detail + +### 6. Graph (Time Series) — `/v5/{ts}/graph?machine={m}&metric={f}` + +The primary performance-over-time visualization. Replaces v4's graph page. + +- **Machine chip input**: The machine selector is a chip-based multi-select input. The user types a machine name (with typeahead suggestions from `renderMachineCombobox`) and presses Enter to add it. Each added machine appears as a chip with an × button to remove it. Multiple machines can be added to overlay their data on the same chart. Removing the last machine clears the chart. The metric selector is shared across all machines — the same metric is plotted for every machine. +- **Auto-plot**: No "Plot" button. The chart loads automatically as soon as at least one machine and a metric are selected. The metric selector initially shows a "-- Select metric --" placeholder (no metric pre-selected), consistent with the Compare page. Adding or removing a machine triggers data fetching (or cache hit) and re-renders the chart immediately. +- **Multi-machine trace naming and symbols**: Each trace is named `{test name} - {machine name}` (test name first for natural sorting). Machines are visually distinguished by marker symbols: the first machine uses circles (default), the second triangles, then squares, diamonds, etc. Colors continue to represent test identity (assigned by alphabetical index of all test names across all machines), so the same test on different machines shares the same color but has a different marker shape. +- **Test filter**: A text filter (like the Compare page) that controls which tests are plotted. The filter matches on **test name only** (not machine name), showing/hiding the test across all machines simultaneously. Each matching test×machine combination becomes a separate trace on the chart. +- **X-axis is always order** (not date — orders are not necessarily correlated to dates) +- Plotly line chart: metric value vs order, one trace per matching test +- **Aggregation controls** (consistent with Compare page): + - Run aggregation: how to combine multiple runs at the same order (median/mean/min/max) + - Sample aggregation: how to combine multiple samples within a run (median/mean/min/max) +- **Lazy loading with progressive rendering**: Data is fetched newest-first (`sort=-order&limit=10000`) and rendered incrementally. The chart first appears with the full x-axis scaffold (if available) and then progressively fills in data as pages arrive via cursor-based pagination (`fetchOneCursorPage`). This avoids blocking the UI on large datasets. +- **X-axis scaffolding**: To prevent the x-axis from resizing/shifting as lazy-loaded pages arrive, the graph page pre-fetches the complete list of order values for each selected machine via paginated calls to the `GET machines/{name}/runs` endpoint (using `fetchOneCursorPage` with `sort=order`). When multiple machines are selected, the scaffold is the **union** of all machines' order values, so the x-axis spans the full range across all machines. Traces naturally have gaps where their machine has no data at a given order. Each machine's scaffold is fetched and cached independently; the union is recomputed when machines are added or removed. If a scaffold fetch fails for one machine, that machine's orders are simply not included in the union — the chart still works. +- **Per-metric client-side caching**: Fetched data is cached per metric key (`machine::metric` combination). Each machine's data is fetched and cached independently. Changing the test filter, aggregation mode, or pinned orders re-renders instantly from the cache without any additional API calls. Switching back to a previously-viewed metric is also instant. Adding a second machine starts its own fetch pipeline while the first machine's data is already displayed. The cache is preserved across page unmount/remount, so navigating away and pressing browser back renders instantly from cache. In-flight fetches are aborted on unmount, but resume from where they left off on remount. Each machine's cache is cleared when that machine is removed from the chip list. +- **Interactive controls**: All settings — metric, test filter, aggregation mode, pinned orders — are interactive from cache. Changing any of them re-renders without an API refetch. All settings sync to the URL for shareability. The legend table updates synchronously (instant feedback while typing), while the chart update is **skipped entirely when the active trace set has not changed** (e.g., typing additional filter characters that match the same tests). When the active set does change, user-initiated changes use **batched rendering**: traces are rendered in batches of 10 via `requestAnimationFrame`, so the chart achieves eventual consistency without freezing the browser — this matters when a filter matches thousands of tests and the 20-cap is disabled. During progressive data loading (new pages arriving from the API), the chart is updated in a single deferred `requestAnimationFrame` call (no batching) to avoid the batch sequence being repeatedly canceled by rapid page arrivals. +- **Incremental chart updates**: The chart component exposes a `ChartHandle` API (via `createTimeSeriesChart`) that supports incremental updates through `Plotly.react()` — the chart is updated in-place as new pages of data arrive, rather than being destroyed and re-created. +- **Zoom preservation during progressive loading**: If the user zooms into the chart while data is still loading, the zoom is preserved across incremental updates. The x-axis range is always preserved (it was established by the scaffold or by user zoom). The y-axis range is preserved only when the user has explicitly zoomed; otherwise, it auto-ranges to accommodate new data as it arrives. Double-clicking the chart resets the zoom to the full range as usual. +- **Legend table**: Below the chart, a table lists traces sorted alphabetically by name (not in a scrollable container — the table is part of the page flow, like the Compare page's table). A message line above the table rows always shows a matching count (e.g., "42 of 150 tests matching"); when the 20-cap is active, the cap warning replaces it. Each row represents one trace (`{test name} - {machine name}`), with a colored marker symbol character (●, ▲, ■, etc. in the trace's color) identifying both the test (by color) and the machine (by shape). The test filter matches on test name only — matching test names show all their machine variants; non-matching names are hidden entirely. Tests that are inactive (manually hidden or beyond the 20-cap) are grayed out in place. Clicking a row toggles the test's visibility on the chart. Double-clicking a row is a shortcut for hiding all other visible tests (equivalent to single-clicking every other test one by one) — it populates `manuallyHidden` with all visible tests except the double-clicked one. Double-clicking the same test again when it is the only visible test restores all tests. Subsequent single-clicks work naturally against the `manuallyHidden` set. Plotly's built-in legend is disabled; the table replaces it. Bidirectional hover highlighting: hovering a table row highlights the corresponding chart trace by emphasizing the entire trace line (thicker line, full opacity) while dimming all other traces via `Plotly.restyle()`; hovering a chart trace highlights the table row. +- **Active state and 20-cap**: A trace is active (plotted) when its test name matches the text filter and it has not been manually hidden by clicking its row. A default 20-test cap auto-activates the first 20 alphabetical trace names when there is no text filter and no manual toggles. As soon as the user types a filter or manually toggles any row, the cap is permanently disabled for the rest of the page session. Colors are assigned by alphabetical index of all **test names** (not trace names) using a fixed palette, ensuring the same test on different machines shares the same color. +- **Pinned Orders**: Users can overlay one or more pinned orders as horizontal dashed lines on the chart. The label is "Pinned Orders" and the text input placeholder is "Pin an order...". On focus, a suggestions dropdown appears showing all machine orders (from the scaffold data) with tagged orders listed first. Typing filters suggestions by prefix matching. A red border appears when the typed value has no prefix matches; pressing Enter is blocked for invalid values. Multiple pinned orders can be accumulated. Each pinned order renders as a horizontal dashed line per test trace, spanning the full chart width, in a distinct color per pinned order. The pinned order's Y value for each test is computed using the same run aggregation function as the main trace (e.g., median of all runs at that order), so the dashed line aligns exactly with the trace point at that order. Hovering a dashed line shows a tooltip with: the pinned order value, tag (if set), test name, and metric value at that order. Pinned orders are encoded in the URL query string for shareability (e.g., `&pin=abc123&pin=def456`). Pinned order data is fetched asynchronously after the first render, so it does not block initial chart display. +- **Concurrent background fetches**: Each machine×metric fetch uses its own AbortController, so navigating away or removing a machine cancels its in-flight requests cleanly without affecting other machines' fetches. +- **Hover** a data point: tooltip showing test name, machine name, order value, aggregated metric value, run count. Hover distance is reduced (`hoverdistance: 5`, less sticky tooltips) so the tooltip only appears when the cursor is close to a data point. When hovering over an aggregated point that represents multiple runs, the individual pre-aggregation values are shown as a scatter of markers at the same x-position, in the same trace color but faded (opacity 0.3). This scatter is computed lazily via a callback and displayed as a temporary Plotly trace that is added on hover and removed on unhover. +- **"No data to plot" annotation**: When no traces match the current filter/settings, the chart displays a Plotly annotation overlay ("No data to plot") centered on the chart area, preserving the x-axis scaffold so the user can see the order range. +- API: `GET query?machine=...&metric=...&sort=-order&limit=10000` (one fetch pipeline per machine, newest-first with cursor pagination — returns data for all tests, filtered client-side), `GET machines/{name}/runs?sort=order` (x-axis scaffold, per machine), `GET orders` (tags for pinned-order suggestions), `GET machines` (machine combobox), `GET test-suites/{ts}` (fields/metrics) +- **URL state**: `?machine={name}&machine={name2}&metric={name}&test_filter={text}&run_agg={fn}&sample_agg={fn}&pin={order1}&pin={order2}` — the `machine` parameter is repeated for each selected machine. +- **Links out**: Compare + +### 7. Compare — `/v5/{ts}/compare` + +Side-by-side comparison of two orders (or runs). The existing code in `comparison.ts`, `selection.ts`, `table.ts`, `chart.ts` becomes a page module. The SPA router delegates to it. + +#### Selection Panel + +Each side (A and B) has independent controls: +- **Order**: combobox (searchable dropdown) over order values (primary order field only; multi-field orders use only the primary field). Displays tags alongside values (e.g., "abc123 (release-18)") and filters suggestions to only show orders where the selected machine has runs. The text filter matches against both the order value and the tag. When a machine is pre-selected from URL state, its orders are fetched on creation so the dropdown is correctly filtered from the start. +- **Machine**: combobox over machine names, filtered via the machines endpoint's `name_prefix` parameter as the user types +- **Runs**: checkbox list of runs for the selected order+machine, populated by `GET /api/v5/{ts}/runs?machine=M&order=O`. Empty list shown when no runs exist. All runs are selected by default. The only exception is URL state restoration: if the shared URL specifies a subset of runs, that selection is restored. +- **Run aggregation**: strategy for aggregating across selected runs (median/mean/min/max); grayed out when only one run selected + +A **Swap sides** button (circular, showing ⇄) sits between the two sides. Clicking it exchanges all of side A's state (order, machine, runs, run aggregation) with side B's, updates the URL, re-renders the selection panel, and triggers auto-compare. This is useful for quickly reversing the baseline/new direction. + +Global controls (shared across both sides): +- **Metric**: single-select dropdown; one metric at a time, applies to both table and chart. Only metrics with `type === 'Real'` are shown (filtered client-side). +- **Sample aggregation**: strategy for aggregating multiple samples within a single run (default: median). When a test appears multiple times in a run's samples, this strategy produces a single value per test per run. +- **Noise threshold**: numeric input defining the minimum |Delta %| to consider significant (default: 1%) +- **Test filter**: text input for substring matching on test names, applied to both table and chart +- **Hide noise**: checkbox that hides noise-status rows from the table and chart + +There is no Compare button. The comparison triggers automatically whenever the state becomes valid (both sides have runs and a metric is selected), like the Graph page's auto-plot. Changing the machine, order, metric, or aggregation settings re-triggers the comparison. Previous in-flight fetches are aborted. + +#### Comparison Table + +| Column | Description | +|----------|----------------------------------------------------------| +| Test | Test name | +| Value A | Aggregated metric value from side A | +| Value B | Aggregated metric value from side B | +| Delta | B - A (absolute difference) | +| Delta % | (B - A) / |A| * 100 (abs ensures sign matches direction of change) | +| Ratio | B / A (same value plotted on the chart) | +| Status | Improved / Regressed / Unchanged (respects bigger_is_better) | + +- **Geomean summary row**: The first row shows a geomean summary. Value A and Value B columns show the geometric mean of absolute values per side (useful for SPEC-like suites where individual values are comparable). Delta and Delta % are computed from these geomeans. The Ratio column shows the geometric mean of per-test ratios (the multiplicative average speedup), which is subtly different from geomean(B)/geomean(A) but is the standard way to report aggregate speedups. +- Sortable by any column (click header) +- Color-coded status: green = improved, red = regressed (direction respects the metric's `bigger_is_better` flag) +- **Noise handling**: rows with |Delta %| below the noise threshold are visually de-emphasized (lighter text, no color). The "Hide noise" checkbox hides them entirely. +- **Missing tests**: tests present in only one side are grayed out in a separate section at the bottom, excluded from the chart +- **Null metrics**: when a test has a sample but no value for the selected metric, display "N/A" in the table and exclude from the chart +- **Zero baseline**: when Value A is 0, display "N/A" for Delta %, Ratio, and Status (raw values are still shown) +- **Interactive rows**: Clicking a row toggles its visibility on the chart. Double-clicking a row isolates it (hides all others), like the Graph page's legend table. Hidden rows are shown grayed out (not removed). The "Hide noise" checkbox is a separate filter applied on top of manual visibility — the two filters are independent: manual toggles persist across hideNoise changes, and changing the noise threshold correctly hides/unhides tests as their status changes. +- **Summary message**: A message above the table rows shows a count, consistent with the Graph page's legend message: "150 tests" when all visible, "120 of 150 tests visible" when some are hidden, or "42 of 150 tests matching" when a text filter or chart zoom is active. + +#### Chart + +Sorted ratio chart (relative performance chart): +- **X-axis**: tests, sorted by B/A ratio +- **Y-axis**: percent change from baseline, linear scale — `(ratio - 1) * 100` so improvements and regressions are symmetric around zero +- Rendered as a connected line (not discrete bars) for readability at scale + +Interactivity: +- **Hover**: tooltip showing test name, exact ratio, and absolute values for both sides +- **Zoom / drag-select**: filters the comparison table to show only the tests in the visible range +- **Noise band**: horizontal reference lines at the +/- noise threshold to visually separate signal from noise +- **Text filter**: the chart applies the text filter from the selection panel; the text filter stacks with the chart zoom filter (intersection) +- **Zoom preservation**: changing noise settings, aggregation functions, text filter, or toggling row visibility preserves the current chart zoom. The user can double-click the chart to reset zoom. +- **Empty state**: when there is no data to chart (no comparison triggered yet, or no tests match), the chart area displays "No data to chart." — consistent with the Graph page's empty-state pattern. + +#### Bidirectional Chart-Table Sync + +The chart and table always represent the same dataset: +- **Chart → Table**: zooming or drag-selecting on the chart filters the table to the matching tests +- **Table → Chart**: the text filter and row toggles update the chart to show only visible, matching tests +- **Hover sync**: hovering on a chart point highlights the table row (scrolls into view); hovering on a table row highlights the chart point + +#### Data Flow + +1. Page loads: fetch metric metadata via `GET test-suites/{ts}` (fields from `schema.metrics`) and all orders via `GET orders` (cursor-paginated) to populate the order comboboxes. +2. User selects order and machine on each side. On each change, fetch `GET runs?machine=M&order=O` to populate the runs checkbox list. If no runs exist, show an empty list. +3. Once both sides have runs and a metric is selected, comparison triggers automatically. Fetch sample data for each selected run via `GET runs/{uuid}/samples` (cursor-paginated with `limit=500`). Show a progress indicator during fetch. +4. Client-side: aggregate samples (within-run via sample aggregation), aggregate across runs (via run aggregation), join on test name, compute derived columns (delta, ratio, status). +5. Render table and chart. +6. Subsequent filter/sort/zoom operations are client-side (data already loaded). +7. If the user changes selections while data is loading, abort the in-flight requests before starting new ones. + +**Per-run sample caching**: Fetched samples are cached per run UUID. Changing the metric, aggregation function, noise threshold, or run selection re-aggregates and re-compares from cache without any API calls. Only selecting a new order or machine (which produces different run UUIDs) triggers new fetches, and only for runs not already in the cache. + +#### URL State + +All selection state is encoded as query parameters for shareability: +- `order_a`, `machine_a`, `runs_a` (comma-separated UUIDs), `run_agg_a` +- `order_b`, `machine_b`, `runs_b`, `run_agg_b` +- `metric`, `sample_agg`, `noise` +- Filter/sort state as applicable + +Auth token is stored in `localStorage`, not in URL state (to avoid leaking credentials when sharing URLs). All URL updates use `replaceState` (not `pushState`) so the browser Back button navigates between pages, not between individual setting changes. + +#### Known Limitations + +- Only single-field orders are supported for the order combobox. Multi-field orders use only the primary field. + +**Links out**: Machine Detail, Run Detail, Graph (with machine pre-filled). + +### 8. Regression List — `/v5/{ts}/regressions` (STUB) + +Placeholder page displaying "Not implemented yet." Will be designed in a later deep dive. + +### 9. Regression Detail — `/v5/{ts}/regressions/{uuid}` (STUB) + +Placeholder page displaying "Not implemented yet." Will be designed in a later deep dive. + +### 10. Field Change Triage — `/v5/{ts}/field-changes` (STUB) + +Placeholder page displaying "Not implemented yet." Will be designed in a later deep dive. + +### 11. Admin — `/v5/admin` + +Not test-suite specific. Served at `/v5/admin` (outside the `{ts}` namespace) with its own Flask route. The SPA shell is served without a testsuite; the admin page reads the list of available test suites from the HTML `data-testsuites` attribute. + +| Tab | Shows | API Calls | +|-----|-------|-----------| +| API Keys | List, create, revoke API keys (global to instance) | `GET/POST/DELETE admin/api-keys` | +| Test Suites | Suite selector, schema viewer, delete suite | `GET/DELETE test-suites` | +| Create Suite | Name input + JSON schema definition textarea | `POST test-suites` | + +**Test Suites tab details**: +- **Suite selector**: Dropdown to switch between test suites. Selecting a suite loads and displays its schema (metrics, order fields, machine fields, run fields). +- **Delete suite**: A delete button per suite. Clicking it shows an inline confirmation panel explaining that deleting a suite permanently destroys all machines, runs, orders, samples, regressions, and field changes, and is irreversible. The user must type the exact suite name to confirm. Calls `DELETE /api/v5/test-suites/{name}?confirm=true`. Requires `manage` scope. + +**Create Suite tab**: +- A name input and a JSON textarea where the user pastes the full suite definition (format_version, name, metrics, run_fields, machine_fields). The JSON format matches the `POST /api/v5/test-suites` API. On success, switches to the Schemas tab with the new suite auto-selected. Requires a token with `manage` scope. + +--- + +## v4 Features NOT Carried Forward + +These v4 pages are intentionally omitted from the v5 UI: + +| v4 Feature | Rationale | +|------------|-----------| +| Daily Report | Subsumed by Dashboard + Graph. The dashboard shows recent activity; the graph page shows trends. | +| Latest Runs Report | Subsumed by Dashboard (recent submissions section). | +| Summary Report | Low usage, "WIP" in v4. Can be added later if needed. | +| Matrix View | Niche use case. The Graph page with per-test drill-down covers the same need. | +| Global Status | Subsumed by Dashboard (active machines + regression summary). | +| Profile Admin | Operational concern, not a core user workflow. Keep in v4. | +| Submit Run page | Runs are submitted via CLI (`lnt submit`) or API. A form-based UI is rarely used. | +| Rules page | Read-only diagnostic page. Keep in v4 for ops. | + +## Frontend Code Structure + +``` +lnt/server/ui/v5/frontend/src/ +├── main.ts Entry point, SPA bootstrap +├── router.ts Client-side URL routing (History API) +├── api.ts Extend existing API client +├── types.ts Extend existing types +├── state.ts Extend existing URL state management +├── events.ts Extend existing custom events +├── utils.ts Extend existing utilities (el(), formatValue(), etc.) +├── combobox.ts Reuse existing combobox widget +├── style.css Extend existing styles +├── pages/ +│ ├── dashboard.ts +│ ├── machine-list.ts +│ ├── machine-detail.ts +│ ├── run-detail.ts +│ ├── order-detail.ts +│ ├── graph.ts +│ ├── compare.ts Compare page module (auto-compare, caching, row toggling) +│ ├── regression-list.ts +│ ├── regression-detail.ts +│ ├── field-change-triage.ts +│ └── admin.ts +└── components/ + ├── nav.ts Navigation bar + ├── data-table.ts Reusable sortable/filterable table + ├── time-series-chart.ts Plotly time-series chart component + ├── machine-combobox.ts Standalone machine typeahead selector + ├── metric-selector.ts Reusable metric drop-down (supports optional placeholder) + ├── order-search.ts Order search with tag-based autocomplete + └── pagination.ts Cursor/offset pagination controls +``` + +### Reuse from Existing Compare Page + +| Existing Module | Reuse Strategy | +|----------------|----------------| +| `api.ts` | Extend with new endpoint functions | +| `types.ts` | Extend with new interfaces | +| `combobox.ts` | Reuse for Compare page order/machine selectors (extended with tag display, machine filtering) | +| `utils.ts` | Reuse `el()`, `formatValue()`, aggregation functions | +| `chart.ts` | Compare page bar chart (extended with text filter, zoom preservation) | +| `table.ts` | Compare page table (extended with row toggling, geomean, summary message) | +| `comparison.ts`, `selection.ts` | Core comparison logic and selection panel, wrapped by `pages/compare.ts` | + +### Build Config Change + +```typescript +// vite.config.ts — output changes from comparison.js to v5.js +lib: { + entry: resolve(__dirname, 'src/main.ts'), + formats: ['iife'], + name: 'LNTv5', + fileName: () => 'v5.js', +}, +outDir: resolve(__dirname, '../static/v5'), +``` + +## API Additions Needed + +**None are blocking.** All v4 workflows can be served by the existing v5 API. + +One optional enhancement for performance: +- `GET /api/v5/{ts}/regressions?include=summary` — enriches list items with `indicator_count`, `earliest_order`, `latest_order` to avoid N+1 fetches on the regression list page. Without this, the frontend can fetch details lazily (regression lists are typically small). + +## Implementation Phases + +| Phase | Pages | Foundation Work | +|-------|-------|-----------------| +| 1 | (none visible) | SPA shell, router, nav bar, Flask catch-all route, build config | +| 2 | Dashboard, Machine List, Machine Detail, Run Detail, Order Detail | Core browsing — read-only pages, data-table component, pagination | +| 3 | Graph | Time-series chart component, combobox integration, aggregation controls, field change annotations | +| 4 | Compare | Absorb existing compare page into SPA as page module, add geomean summary | +| 5 | Regression List, Regression Detail, Field Change Triage (stubs) | Stub pages with "Not implemented yet" message | +| 6 | Admin, polish | API key management, error handling, loading states | + +## Verification + +After each phase, verify by: +1. Running the dev server (`lnt runserver`) and navigating to `http://localhost:8000/v5/{ts}/` +2. Checking that SPA routing works (browser back/forward, direct URL access) +3. Checking that all API calls succeed (browser DevTools Network tab) +4. Running Vitest unit tests: `cd lnt/server/ui/v5/frontend && npm test` +5. Checking that the v4 UI is unaffected (navigate to `/v4/{ts}/recent_activity`) +6. Checking the v4↔v5 toggle links work in both directions diff --git a/docs/developer_guide.rst b/docs/developer_guide.rst index a4e944ea6..83e8275ee 100644 --- a/docs/developer_guide.rst +++ b/docs/developer_guide.rst @@ -19,8 +19,8 @@ virtual environment and installing the development dependencies:: pip install ".[dev]" This will install the current version of the package, along with the dependencies -required for development (``lit``, ``filecheck``, etc). Note that ``curl``, ``jq`` -and ``docker`` are also required for running the tests. +required for development (``lit``, ``filecheck``, etc). Note that ``curl``, ``jq``, +``docker`` and ``npm`` (Node.js) are also required for running the tests. Running LNT's Regression Tests ------------------------------ diff --git a/docs/v5-ui-implementation-plan.md b/docs/v5-ui-implementation-plan.md new file mode 100644 index 000000000..3e03229d3 --- /dev/null +++ b/docs/v5-ui-implementation-plan.md @@ -0,0 +1,2165 @@ +# v5 Web UI Redesign — Implementation Plan + +This document is a step-by-step implementation plan for the v5 Web UI redesign described in `docs/design/v5-ui.md`. Each phase includes the exact file changes, new modules, API function signatures, type definitions, and testing strategy needed for a developer to execute independently. + +## Prerequisite Reading + +Before starting, read: +- `docs/design/v5-ui.md` — the high-level design +- All existing frontend source in `lnt/server/ui/v5/frontend/src/` +- The v5 API endpoints in `lnt/server/api/v5/endpoints/` + +--- + +## Phase 1: SPA Scaffolding + +**Goal**: Transform the existing Compare-only page into an SPA shell with client-side routing, a navigation bar, and a catch-all Flask route. The Compare page must keep working throughout. + +### 1.1 Build Config Changes + +**File**: `lnt/server/ui/v5/frontend/vite.config.ts` + +Change the output from `comparison.js` / `comparison.css` to `v5.js` / `v5.css`, with a new output directory: + +```typescript +import { defineConfig } from 'vite'; +import { resolve } from 'path'; + +export default defineConfig({ + build: { + outDir: resolve(__dirname, '../static/v5'), + emptyOutDir: true, + sourcemap: true, + lib: { + entry: resolve(__dirname, 'src/main.ts'), + formats: ['iife'], + name: 'LNTv5', + fileName: () => 'v5.js', + }, + rollupOptions: { + external: ['plotly.js-dist'], + output: { + globals: { + 'plotly.js-dist': 'Plotly', + }, + assetFileNames: 'v5[extname]', + }, + }, + }, +}); +``` + +**Migration note**: The old `static/comparison/` directory should be kept temporarily until all templates are updated. After Phase 1 is complete and verified, delete `static/comparison/`. + +**Packaging note**: When the build output path changes, `pyproject.toml` `[tool.setuptools.package-data]` and `MANIFEST.in` must be updated to match. The package-data globs for `lnt.server.ui.v5` must include `static/v5/*.js`, `static/v5/*.css`, and `static/v5/*.map`. Without this, the static assets are silently excluded from the installed package (editable installs work because they serve from the source tree, but `pip install` in Docker does not). + +### 1.2 Package.json + +**File**: `lnt/server/ui/v5/frontend/package.json` + +No dependency changes needed. The existing `vite`, `vitest`, `typescript`, and `jsdom` are sufficient. The `build` and `test` scripts remain the same. + +### 1.3 New SPA Shell Template + +**File**: `lnt/server/ui/v5/templates/v5_app.html` (new file) + +This is a standalone HTML page (does NOT extend `layout.html`). The v5 SPA renders its own navigation bar, CSS, and JS — inheriting the v4 layout would pull in Bootstrap 2, jQuery, DataTables, and layout artifacts (97px fixed-navbar margin, sticky footer) that conflict with the SPA. + +```html + + + + + + {{ old_config.name }} : {{ g.testsuite_name }} - v5 UI + + + + + + +
+
+ + + +``` + +The `data-testsuites` attribute provides the list of available test suite names (for the suite selector in the nav bar). The `data-v4-url` attribute provides the v4 URL for the toggle link. + +**Note on `| tojson | forceescape`**: Flask's `tojson` returns a `Markup` object (marked HTML-safe), so Jinja2's `| e` filter is a no-op on it. Using `| forceescape` ensures the JSON double-quotes are escaped to `"` inside the HTML attribute. Without this, the raw `"` in the JSON would terminate the attribute and break `JSON.parse()` at runtime. + +### 1.4 Flask Backend Changes + +**File**: `lnt/server/ui/v5/views.py` + +Add a catch-all route for the SPA and update the existing compare route. The v5 UI does not include `db_` in its URL namespace. + +```python +from flask import render_template, request + +from . import v5_frontend, _setup_testsuite +from lnt.server.ui.views import ts_data + + +@v5_frontend.route("/v5//") +@v5_frontend.route("/v5//") +def v5_app(testsuite_name, subpath=None): + """Catch-all route for the v5 SPA. + + All client-side routes (dashboard, machines, graph, compare, etc.) + hit this single endpoint, which serves the SPA shell. The TypeScript + router handles the rest. + """ + _setup_testsuite(testsuite_name) + try: + ts = request.get_testsuite() + data = ts_data(ts) + # Add test suite names for the suite selector + db = request.get_db() + data['testsuites'] = sorted(db.testsuite.keys()) + return render_template("v5_app.html", **data) + finally: + request.session.close() + + +# Keep the old compare route for backward compatibility during transition. +# Once Phase 4 absorbs Compare into the SPA, this route can be removed. +@v5_frontend.route("/v5//compare") +@v5_frontend.route("/db_/v5//compare") +def v5_compare(testsuite_name, db_name=None): + _setup_testsuite(testsuite_name, db_name) + try: + ts = request.get_testsuite() + return render_template("v5_compare.html", **ts_data(ts)) + finally: + request.session.close() +``` + +**Important**: The catch-all route `` will also match `/compare`. During Phases 1-3, the old `v5_compare` route (registered first, more specific) takes priority and serves the standalone Compare page via `v5_compare.html`. In Phase 4, the old route is deleted and the catch-all serves the SPA shell for all paths including `/compare`. + +The simplest approach: remove the `db_` variant of `v5_compare` immediately (it was never the intended v5 pattern), and keep the non-prefixed `v5_compare` route as a temporary bridge until Phase 4. + +### 1.5 Client-Side Router + +**File**: `lnt/server/ui/v5/frontend/src/router.ts` (new file) + +A minimal path-based router using the History API. Each route maps a URL pattern to a page module that has `mount(container, params)` and `unmount()` functions. + +```typescript +// router.ts — Client-side URL routing + +export interface PageModule { + /** Render the page into the container. Called on navigation. */ + mount(container: HTMLElement, params: RouteParams): void | Promise; + /** Clean up when navigating away. Optional. */ + unmount?(): void; +} + +export interface RouteParams { + testsuite: string; + /** Named captures from the route pattern, e.g. { name: "machine-1" } */ + [key: string]: string; +} + +interface RouteEntry { + /** Regex compiled from the route pattern */ + regex: RegExp; + /** Named group keys in order */ + keys: string[]; + /** The page module to mount */ + module: PageModule; +} + +const routes: RouteEntry[] = []; +let currentModule: PageModule | null = null; +let appContainer: HTMLElement | null = null; +let basePath = ''; // e.g. "/v5/nts" + +/** + * Register a route. Pattern uses Express-style `:param` syntax. + * Example: "/machines/:name" matches "/machines/clang-x86" + */ +export function addRoute(pattern: string, module: PageModule): void { + const keys: string[] = []; + // Convert ":param" to named regex groups + const regexStr = pattern + .replace(/:([a-zA-Z_]+)/g, (_match, key) => { + keys.push(key); + return '([^/]+)'; + }); + routes.push({ + regex: new RegExp('^' + regexStr + '$'), + keys, + module, + }); +} + +/** + * Initialize the router. + * @param container The DOM element to render pages into + * @param tsBasePath The base path, e.g. "/v5/nts" + */ +export function initRouter(container: HTMLElement, tsBasePath: string): void { + appContainer = container; + basePath = tsBasePath; + + window.addEventListener('popstate', () => { + resolve(); + }); + + // Initial route resolution + resolve(); +} + +/** + * Navigate to a path (relative to the testsuite base). + * Example: navigate("/machines/clang-x86") + */ +export function navigate(path: string): void { + const fullPath = basePath + path; + window.history.pushState(null, '', fullPath + window.location.search); + resolve(); +} + +/** + * Navigate to a path with query string. + */ +export function navigateWithQuery(path: string, query: string): void { + const fullPath = basePath + path; + const qs = query ? '?' + query : ''; + window.history.pushState(null, '', fullPath + qs); + resolve(); +} + +/** + * Resolve the current URL to a route and mount the corresponding page. + */ +function resolve(): void { + if (!appContainer) return; + + const pathname = window.location.pathname; + // Strip basePath prefix to get the route portion + let routePath = pathname; + if (pathname.startsWith(basePath)) { + routePath = pathname.slice(basePath.length); + } + // Ensure it starts with / + if (!routePath.startsWith('/')) { + routePath = '/' + routePath; + } + // Normalize: strip trailing slash (except for root "/") + if (routePath.length > 1 && routePath.endsWith('/')) { + routePath = routePath.slice(0, -1); + } + + // Root path "/" maps to the dashboard + if (routePath === '' || routePath === '/') { + routePath = '/'; + } + + for (const route of routes) { + const match = routePath.match(route.regex); + if (match) { + const params: RouteParams = { + testsuite: basePath.split('/').pop() || '', + }; + route.keys.forEach((key, i) => { + params[key] = decodeURIComponent(match[i + 1]); + }); + + // Unmount previous page + if (currentModule?.unmount) { + currentModule.unmount(); + } + + // Clear container + appContainer.replaceChildren(); + + // Mount new page + currentModule = route.module; + currentModule.mount(appContainer, params); + return; + } + } + + // No route matched — show 404 + if (currentModule?.unmount) { + currentModule.unmount(); + } + currentModule = null; + appContainer.replaceChildren(); + const msg = document.createElement('div'); + msg.style.padding = '40px'; + msg.style.textAlign = 'center'; + msg.style.color = '#666'; + msg.innerHTML = '

Page Not Found

The URL does not match any v5 page.

'; + appContainer.appendChild(msg); +} +``` + +**Route table** (registered in `main.ts`): + +| Pattern | Page Module | +|---------|-------------| +| `/` | `pages/dashboard` | +| `/machines` | `pages/machine-list` | +| `/machines/:name` | `pages/machine-detail` | +| `/runs/:uuid` | `pages/run-detail` | +| `/orders/:value` | `pages/order-detail` | +| `/graph` | `pages/graph` | +| `/compare` | `pages/compare` | +| `/regressions` | `pages/regression-list` | +| `/regressions/:uuid` | `pages/regression-detail` | +| `/field-changes` | `pages/field-change-triage` | +| `/admin` | `pages/admin` | + +### 1.6 Navigation Bar Component + +**File**: `lnt/server/ui/v5/frontend/src/components/nav.ts` (new file) + +Renders a persistent navigation bar above the page content. The nav bar is rendered once by `main.ts` and is not re-rendered on route changes; instead, the active link is updated. + +```typescript +// components/nav.ts — Navigation bar + +import { el } from '../utils'; +import { navigate } from '../router'; + +export interface NavConfig { + testsuite: string; + testsuites: string[]; + v4Url: string; + urlBase: string; // lnt_url_base +} + +let activeLink: HTMLElement | null = null; + +/** + * Render the navigation bar. + * Returns the nav element to prepend to the app root. + */ +export function renderNav(config: NavConfig): HTMLElement { + const nav = el('nav', { class: 'v5-nav' }); + + // Brand + const brand = el('a', { class: 'v5-nav-brand', href: '#' }, 'LNT'); + brand.addEventListener('click', (e) => { + e.preventDefault(); + navigate('/'); + }); + nav.append(brand); + + // Test suite selector + const suiteSelect = el('select', { class: 'v5-nav-suite-select' }) as HTMLSelectElement; + for (const name of config.testsuites) { + const opt = el('option', { value: name }, name); + if (name === config.testsuite) { + (opt as HTMLOptionElement).selected = true; + } + suiteSelect.append(opt); + } + suiteSelect.addEventListener('change', () => { + // Navigate to the dashboard of the selected test suite + const newSuite = suiteSelect.value; + window.location.href = `${config.urlBase}/v5/${encodeURIComponent(newSuite)}/`; + }); + const suiteGroup = el('div', { class: 'v5-nav-suite' }); + suiteGroup.append(el('span', {}, 'Suite: '), suiteSelect); + nav.append(suiteGroup); + + // Navigation links + const links: { label: string; path: string }[] = [ + { label: 'Dashboard', path: '/' }, + { label: 'Graph', path: '/graph' }, + { label: 'Compare', path: '/compare' }, + { label: 'Regressions', path: '/regressions' }, + { label: 'Machines', path: '/machines' }, + { label: 'Admin', path: '/admin' }, + ]; + + const linksContainer = el('div', { class: 'v5-nav-links' }); + for (const link of links) { + const a = el('a', { + class: 'v5-nav-link', + href: '#', + 'data-path': link.path, + }, link.label); + a.addEventListener('click', (e) => { + e.preventDefault(); + navigate(link.path); + }); + linksContainer.append(a); + } + nav.append(linksContainer); + + // Right side: v4 toggle + Settings + const rightGroup = el('div', { class: 'v5-nav-right' }); + + const v4Link = el('a', { class: 'v5-nav-link', href: config.v4Url }, 'v4 UI'); + rightGroup.append(v4Link); + + const settingsLink = el('a', { + class: 'v5-nav-link', + href: '#', + }, 'Settings'); + settingsLink.addEventListener('click', (e) => { + e.preventDefault(); + toggleSettings(); + }); + rightGroup.append(settingsLink); + nav.append(rightGroup); + + return nav; +} + +/** + * Update the active link in the nav bar based on the current route. + * Call this after each route resolution. + */ +export function updateActiveNavLink(currentPath: string): void { + if (activeLink) { + activeLink.classList.remove('v5-nav-link-active'); + } + + const links = document.querySelectorAll('.v5-nav-link[data-path]'); + for (const link of links) { + const path = link.getAttribute('data-path'); + if (!path) continue; + + // Exact match for "/" (dashboard), prefix match for others + if (path === '/') { + if (currentPath === '/' || currentPath === '') { + link.classList.add('v5-nav-link-active'); + activeLink = link; + } + } else if (currentPath.startsWith(path)) { + link.classList.add('v5-nav-link-active'); + activeLink = link; + } + } +} + +/** Settings panel toggle (token input). Reuses the existing pattern. */ +function toggleSettings(): void { + let panel = document.getElementById('v5-settings-panel'); + if (panel) { + panel.style.display = panel.style.display === 'none' ? 'block' : 'none'; + return; + } + + // Create settings panel + panel = el('div', { id: 'v5-settings-panel', class: 'settings-panel' }); + panel.append(el('label', {}, 'Auth Token')); + const tokenInput = el('input', { + type: 'password', + class: 'token-input', + placeholder: 'Paste v5 API token...', + }) as HTMLInputElement; + tokenInput.value = localStorage.getItem('lnt_v5_token') || ''; + tokenInput.addEventListener('change', () => { + const val = tokenInput.value.trim(); + if (val) localStorage.setItem('lnt_v5_token', val); + else localStorage.removeItem('lnt_v5_token'); + }); + panel.append(tokenInput); + + // Insert after the nav + const nav = document.querySelector('.v5-nav'); + if (nav && nav.parentElement) { + nav.parentElement.insertBefore(panel, nav.nextSibling); + } +} +``` + +### 1.7 Refactor main.ts + +**File**: `lnt/server/ui/v5/frontend/src/main.ts` + +The entry point changes from Compare-only to SPA bootstrap. The existing compare logic moves to `pages/compare.ts` (Phase 4), but during Phase 1 we set up the skeleton with a placeholder compare page that delegates to the existing modules. + +```typescript +// main.ts — SPA entry point + +import { setApiBase } from './api'; +import { addRoute, initRouter } from './router'; +import { renderNav, updateActiveNavLink } from './components/nav'; +import { el } from './utils'; +import './style.css'; + +// Page modules (added incrementally across phases) +import { dashboardPage } from './pages/dashboard'; +import { machineListPage } from './pages/machine-list'; +import { machineDetailPage } from './pages/machine-detail'; +import { runDetailPage } from './pages/run-detail'; +import { orderDetailPage } from './pages/order-detail'; +import { graphPage } from './pages/graph'; +import { comparePage } from './pages/compare'; +import { regressionListPage } from './pages/regression-list'; +import { regressionDetailPage } from './pages/regression-detail'; +import { fieldChangeTriagePage } from './pages/field-change-triage'; +import { adminPage } from './pages/admin'; + +declare const lnt_url_base: string; + +function init(): void { + const root = document.getElementById('v5-app'); + if (!root) return; + + const testsuite = root.getAttribute('data-testsuite') || ''; + if (!testsuite) { + root.textContent = 'Error: no testsuite specified.'; + return; + } + + const testsuites: string[] = JSON.parse( + root.getAttribute('data-testsuites') || '[]' + ); + const v4Url = root.getAttribute('data-v4-url') || '#'; + + // Set API base from global set in v5_app.html + const urlBase = typeof lnt_url_base !== 'undefined' ? lnt_url_base : ''; + setApiBase(urlBase); + + // Render nav bar (persistent across route changes) + const nav = renderNav({ testsuite, testsuites, v4Url, urlBase }); + root.append(nav); + + // Page content container + const pageContainer = el('div', { id: 'v5-page' }); + root.append(pageContainer); + + // Register routes + addRoute('/', dashboardPage); + addRoute('/machines', machineListPage); + addRoute('/machines/:name', machineDetailPage); + addRoute('/runs/:uuid', runDetailPage); + addRoute('/orders/:value', orderDetailPage); + addRoute('/graph', graphPage); + addRoute('/compare', comparePage); + addRoute('/regressions', regressionListPage); + addRoute('/regressions/:uuid', regressionDetailPage); + addRoute('/field-changes', fieldChangeTriagePage); + addRoute('/admin', adminPage); + + // Initialize router (resolves current URL) + const basePath = `${urlBase}/v5/${encodeURIComponent(testsuite)}`; + initRouter(pageContainer, basePath); +} + +// Start +if (document.readyState === 'loading') { + document.addEventListener('DOMContentLoaded', init); +} else { + init(); +} +``` + +**During Phase 1**, most page modules will be stubs (see section 1.8). Only the router, nav, and skeleton need to work. + +### 1.8 SPA Link Utility + +**File**: `lnt/server/ui/v5/frontend/src/utils.ts` (extend) + +Add a `spaLink` helper that all page modules use for internal navigation. This ensures links use the SPA router instead of triggering full page reloads. + +```typescript +import { navigate } from './router'; + +/** + * Create an anchor element that navigates via the SPA router. + * All internal links across all pages should use this helper. + */ +export function spaLink(text: string, path: string): HTMLElement { + const a = el('a', { href: '#', class: 'spa-link' }, text); + a.addEventListener('click', (e) => { + e.preventDefault(); + navigate(path); + }); + return a; +} +``` + +### 1.9 Stub Page Modules for Phase 1 + +During Phase 1, create minimal stub modules for every page. Each follows the `PageModule` interface. + +**File pattern**: `lnt/server/ui/v5/frontend/src/pages/.ts` + +Example stub (`pages/dashboard.ts`): + +```typescript +import type { PageModule, RouteParams } from '../router'; +import { el } from '../utils'; + +export const dashboardPage: PageModule = { + mount(container: HTMLElement, params: RouteParams): void { + container.append( + el('div', { class: 'page-placeholder' }, + el('h2', {}, 'Dashboard'), + el('p', {}, 'Coming soon in Phase 2.'), + ) + ); + }, +}; +``` + +Create identical stubs for all pages: `machine-list.ts`, `machine-detail.ts`, `run-detail.ts`, `order-detail.ts`, `graph.ts`, `compare.ts`, `regression-list.ts`, `regression-detail.ts`, `field-change-triage.ts`, `admin.ts`. + +For `compare.ts`, the stub should initially say "Coming soon" but will be replaced in Phase 4 with the full compare integration. + +### 1.10 Nav Bar CSS + +**File**: `lnt/server/ui/v5/frontend/src/style.css` (append to existing) + +Add styles for the nav bar and page container. These extend the existing styles without modifying them. + +```css +/* ============================================================ + v5 SPA Navigation Bar + ============================================================ */ + +.v5-nav { + display: flex; + align-items: center; + gap: 12px; + padding: 8px 15px; + background: #343a40; + border-radius: 4px; + margin-bottom: 15px; + flex-wrap: wrap; +} + +.v5-nav-brand { + color: #fff; + font-weight: 700; + font-size: 16px; + text-decoration: none; + margin-right: 8px; +} + +.v5-nav-brand:hover { + color: #ddd; +} + +.v5-nav-suite { + display: flex; + align-items: center; + gap: 4px; + color: #adb5bd; + font-size: 13px; +} + +.v5-nav-suite-select { + padding: 2px 6px; + border: 1px solid #555; + border-radius: 3px; + background: #495057; + color: #fff; + font-size: 12px; +} + +.v5-nav-links { + display: flex; + gap: 4px; + flex: 1; +} + +.v5-nav-link { + color: #adb5bd; + text-decoration: none; + font-size: 13px; + padding: 4px 10px; + border-radius: 3px; +} + +.v5-nav-link:hover { + color: #fff; + background: #495057; +} + +.v5-nav-link-active { + color: #fff; + background: #0d6efd; +} + +.v5-nav-right { + display: flex; + gap: 4px; + margin-left: auto; +} + +/* Page container */ +#v5-page { + min-height: 300px; +} + +.page-placeholder { + padding: 40px; + text-align: center; + color: #666; +} + +.page-placeholder h2 { + margin-bottom: 10px; +} +``` + +### 1.11 Phase 1 Testing + +**Unit tests for `router.ts`** (`__tests__/router.test.ts`): +- Route matching: exact paths, parameterized paths, no match yields 404 +- `navigate()` calls `pushState` and mounts the correct module +- `popstate` event triggers re-resolution +- `basePath` stripping works correctly +- Trailing slash normalization + +**Unit tests for `components/nav.ts`** (`__tests__/nav.test.ts`): +- Renders all expected links +- Suite selector contains all test suites with correct selected value +- Click on nav link calls `navigate()` +- Active link highlight updates correctly +- Settings toggle creates/shows/hides the token panel + +**Manual verification**: +1. Run `cd lnt/server/ui/v5/frontend && npm run build` +2. Start dev server: `lnt runserver` +3. Navigate to `http://localhost:8000/v5/nts/` — should see nav bar + Dashboard stub +4. Click each nav link — URL changes, stub content updates, no full page reload +5. Browser back/forward works +6. Direct URL access (e.g., `/v5/nts/machines`) works (Flask catch-all serves SPA shell) +7. Test suite selector changes URL and reloads +8. v4 UI link navigates to v4 page +9. Old Compare URL (`/v5/nts/compare`) still works (either via old route or catch-all) + +--- + +## Phase 2: Core Browsing Pages + +**Goal**: Implement the five read-only browsing pages: Dashboard, Machine List, Machine Detail, Run Detail, and Order Detail. + +### 2.1 New API Functions + +**File**: `lnt/server/ui/v5/frontend/src/api.ts` (extend existing) + +Add the following functions. Signatures are based on the actual v5 API endpoint parameters and responses. + +```typescript +// --- New types needed (add to types.ts) --- + +export interface OrderDetail { + fields: Record; + tag: string | null; + previous_order: OrderNeighbor | null; + next_order: OrderNeighbor | null; +} + +export interface OrderNeighbor { + fields: Record; + link: string; +} + +export interface RunDetail { + uuid: string; + machine: string; + order: Record; + start_time: string | null; + end_time: string | null; + parameters: Record; +} + +export interface TestInfo { + name: string; +} + +export interface QueryDataPoint { + test: string; + machine: string; + metric: string; + value: number; + order: Record; + run_uuid: string; + timestamp: string | null; +} + +export interface FieldChangeInfo { + uuid: string; + test: string | null; + machine: string | null; + metric: string | null; + old_value: number; + new_value: number; + start_order: string | null; + end_order: string | null; + run_uuid: string | null; +} + +export interface SchemaInfo { + schema: Record; +} + +export interface APIKeyInfo { + prefix: string; + name: string; + scope: string; + created_at: string; + last_used_at: string | null; + is_active: boolean; +} + +// --- New API functions (add to api.ts) --- + +/** Get a single machine by name. */ +export async function getMachine( + ts: string, + name: string, + signal?: AbortSignal, +): Promise { + return fetchJson( + apiUrl(ts, `machines/${encodeURIComponent(name)}`), + undefined, + signal, + ); +} + +/** Get runs for a machine (cursor-paginated). + * sort: e.g. "-start_time" for newest first. */ +export async function getMachineRuns( + ts: string, + machineName: string, + opts?: { sort?: string; limit?: number; cursor?: string }, + signal?: AbortSignal, +): Promise> { + const params: Record = {}; + if (opts?.sort) params.sort = opts.sort; + if (opts?.limit) params.limit = String(opts.limit); + if (opts?.cursor) params.cursor = opts.cursor; + return fetchJson>( + apiUrl(ts, `machines/${encodeURIComponent(machineName)}/runs`), + params, + signal, + ); +} + +/** Get a single run by UUID. */ +export async function getRun( + ts: string, + uuid: string, + signal?: AbortSignal, +): Promise { + return fetchJson( + apiUrl(ts, `runs/${encodeURIComponent(uuid)}`), + undefined, + signal, + ); +} + +/** Get order detail by primary field value (includes prev/next). */ +export async function getOrder( + ts: string, + value: string, + signal?: AbortSignal, +): Promise { + return fetchJson( + apiUrl(ts, `orders/${encodeURIComponent(value)}`), + undefined, + signal, + ); +} + +/** List runs filtered by order value. */ +export async function getRunsByOrder( + ts: string, + orderValue: string, + signal?: AbortSignal, +): Promise { + return fetchAllCursorPages( + apiUrl(ts, 'runs'), + { order: orderValue }, + signal, + ); +} + +/** List tests (cursor-paginated, filterable). */ +export async function getTests( + ts: string, + opts?: { nameContains?: string; limit?: number; cursor?: string }, + signal?: AbortSignal, +): Promise> { + const params: Record = {}; + if (opts?.nameContains) params.name_contains = opts.nameContains; + if (opts?.limit) params.limit = String(opts.limit); + if (opts?.cursor) params.cursor = opts.cursor; + return fetchJson>( + apiUrl(ts, 'tests'), + params, + signal, + ); +} + +/** Query data points (the main query endpoint). + * Auto-paginates and returns all matching data points. */ +export async function queryDataPoints( + ts: string, + opts: { + machine?: string; + test?: string; + metric?: string; + afterOrder?: string; + beforeOrder?: string; + sort?: string; + }, + signal?: AbortSignal, + onProgress?: (loaded: number) => void, +): Promise { + const params: Record = {}; + if (opts.machine) params.machine = opts.machine; + if (opts.test) params.test = opts.test; + if (opts.metric) params.metric = opts.metric; + if (opts.afterOrder) params.after_order = opts.afterOrder; + if (opts.beforeOrder) params.before_order = opts.beforeOrder; + if (opts.sort) params.sort = opts.sort; + return fetchAllCursorPages( + apiUrl(ts, 'query'), + params, + signal, + onProgress, + ); +} + +/** List field changes (unassigned, cursor-paginated). */ +export async function getFieldChanges( + ts: string, + opts?: { limit?: number; cursor?: string }, + signal?: AbortSignal, +): Promise> { + const params: Record = {}; + if (opts?.limit) params.limit = String(opts.limit); + if (opts?.cursor) params.cursor = opts.cursor; + return fetchJson>( + apiUrl(ts, 'field-changes'), + params, + signal, + ); +} + +/** Get schema for a test suite. */ +export async function getSchema( + ts: string, + signal?: AbortSignal, +): Promise { + return fetchJson( + apiUrl(ts, 'schema'), + undefined, + signal, + ); +} + +/** List API keys (admin endpoint, no testsuite prefix). */ +export async function getApiKeys( + signal?: AbortSignal, +): Promise<{ items: APIKeyInfo[] }> { + return fetchJson<{ items: APIKeyInfo[] }>( + `${apiBase}/api/v5/admin/api-keys`, + undefined, + signal, + ); +} + +/** Search orders by tag prefix (for order search autocomplete). */ +export async function searchOrdersByTag( + ts: string, + tagPrefix: string, + opts?: { limit?: number }, + signal?: AbortSignal, +): Promise> { + const params: Record = { tag_prefix: tagPrefix }; + if (opts?.limit) params.limit = String(opts.limit); + return fetchJson>( + apiUrl(ts, 'orders'), + params, + signal, + ); +} + +/** Update the tag on an order. Requires `manage` scope token. */ +export async function updateOrderTag( + ts: string, + orderValue: string, + tag: string | null, + signal?: AbortSignal, +): Promise { + return fetchJson( + apiUrl(ts, `orders/${encodeURIComponent(orderValue)}`), + { method: 'PATCH', body: { tag }, signal }, + ); +} +``` + +**Note**: `fetchJson` and `apiUrl` are existing internal functions in `api.ts`. The new functions above call them directly. `fetchAllCursorPages` is also already available for functions that need to auto-paginate. + +For `getMachineRuns` and other paginated endpoints where we want to show pagination controls (not auto-fetch all pages), we return `CursorPaginated` directly instead of using `fetchAllCursorPages`. + +**Note on `getFields`**: The pre-existing `getFields(ts)` function (from the Compare page) fetches field/metric metadata via `GET /api/v5/test-suites/{ts}` and extracts `schema.metrics` from the response. There is no dedicated `/fields` endpoint — metric definitions are part of the test suite schema. + +### 2.2 Shared Components + +#### 2.2.1 Data Table Component + +**File**: `lnt/server/ui/v5/frontend/src/components/data-table.ts` (new file) + +A reusable sortable, filterable table component. Generalizes the patterns from the existing `table.ts` (comparison table) into a configurable component. + +```typescript +// components/data-table.ts + +import { el } from '../utils'; + +export interface Column { + key: string; + label: string; + /** Extract the display value from a row. Defaults to row[key]. */ + render?: (row: T) => string | Node; + /** Extract a sortable value. Defaults to row[key]. */ + sortValue?: (row: T) => string | number | null; + /** CSS class for the cell. */ + cellClass?: string; + /** Whether this column is sortable (default true). */ + sortable?: boolean; +} + +export interface DataTableOptions { + columns: Column[]; + rows: T[]; + /** Initial sort column key. */ + sortKey?: string; + /** Initial sort direction. */ + sortDir?: 'asc' | 'desc'; + /** Callback when a row is clicked. */ + onRowClick?: (row: T) => void; + /** CSS class for rows (return a class string per row). */ + rowClass?: (row: T) => string; + /** Empty state message. */ + emptyMessage?: string; +} + +/** + * Render a data table into the given container. + * Returns a handle to update the data without full re-render. + */ +export function renderDataTable( + container: HTMLElement, + options: DataTableOptions, +): void { + // Implementation: build with sortable headers, + // re-sort on header click, call onRowClick on row click. + // Follows the same styling patterns as .comparison-table. + // ... +} +``` + +The full implementation builds a `
` with: +- Sortable column headers (click to toggle asc/desc, indicator arrows) +- Row click handler for navigation +- Optional row CSS classes +- Empty state message +- Uses existing CSS classes (`.comparison-table`, `.col-num`, `.sortable`, etc.) for consistency + +#### 2.2.2 Pagination Component + +**File**: `lnt/server/ui/v5/frontend/src/components/pagination.ts` (new file) + +```typescript +// components/pagination.ts + +import { el } from '../utils'; + +export interface PaginationOptions { + /** Whether there is a previous page (cursor-based). */ + hasPrevious: boolean; + /** Whether there is a next page. */ + hasNext: boolean; + /** Callback when Previous is clicked. */ + onPrevious: () => void; + /** Callback when Next is clicked. */ + onNext: () => void; + /** Optional: current item range for display, e.g. "1-25 of 150". */ + rangeText?: string; +} + +/** + * Render pagination controls (Previous / Next buttons + range text). + */ +export function renderPagination( + container: HTMLElement, + options: PaginationOptions, +): void { + const row = el('div', { class: 'pagination-controls' }); + + const prevBtn = el('button', { + class: 'pagination-btn', + disabled: options.hasPrevious ? false : true, + }, 'Previous') as HTMLButtonElement; + prevBtn.addEventListener('click', options.onPrevious); + + const nextBtn = el('button', { + class: 'pagination-btn', + disabled: options.hasNext ? false : true, + }, 'Next') as HTMLButtonElement; + nextBtn.addEventListener('click', options.onNext); + + if (options.rangeText) { + row.append(el('span', { class: 'pagination-range' }, options.rangeText)); + } + + row.append(prevBtn, nextBtn); + container.append(row); +} +``` + +#### 2.2.3 Order Search Component + +**File**: `lnt/server/ui/v5/frontend/src/components/order-search.ts` (new file) + +A search input for navigating to an order by value or tag. Used by Order Detail (for jumping to an arbitrary order) and later by Graph (for adding pinned orders). + +```typescript +// components/order-search.ts + +import { el, debounce } from '../utils'; +import { searchOrdersByTag } from '../api'; +import { navigate } from '../router'; + +export interface OrderSuggestion { + orderValue: string; + tag: string | null; +} + +export interface OrderSearchOptions { + /** Test suite name. */ + testsuite: string; + /** Placeholder text for the input. */ + placeholder?: string; + /** Callback when an order is selected. If not provided, navigates to Order Detail. */ + onSelect?: (orderValue: string) => void; + /** + * Pre-populated suggestions to show on focus (before the user types). + * Used by the Graph page to provide all machine orders with tagged + * orders listed first. + * + * The component has two distinct modes based on whether this field is provided: + * - **Suggestions mode** (`suggestions` provided, even as `[]`): the dropdown + * only shows items from this list, filtered by prefix. The API is never called. + * Validation (red border, Enter blocked) is active. Use `setSuggestions()` + * to populate the list after creation (e.g., once the scaffold loads). + * - **API mode** (`suggestions` omitted / `undefined`): typing triggers a + * debounced `tag_prefix` API search. No validation is applied. + */ + suggestions?: OrderSuggestion[]; +} + +/** + * Render an order search input with autocomplete dropdown. + * + * Two modes determined by whether `options.suggestions` is provided: + * + * **API mode** (suggestions omitted): + * - On each keystroke (debounced 300ms): calls GET /orders?tag_prefix={input}&limit=10 + * to find orders whose tag matches the typed prefix. + * - Shows results in a dropdown. Each item displays: primary order value + tag (if set). + * - On Enter: navigates directly to /orders/{inputValue} (exact order value lookup). + * - On dropdown item click: navigates to that order (or calls onSelect callback). + * + * **Suggestions mode** (suggestions provided, even as []): + * - On focus, the dropdown shows all suggestions with tagged orders listed first. + * - Typing filters suggestions by prefix matching (no API call). + * - A red border appears when the typed value has no prefix matches. + * - Pressing Enter is blocked when the input has no matches (red border state). + * - Use `setSuggestions()` to update the list after creation (e.g., once scaffold data loads). + * During the initial period before setSuggestions() is called, the dropdown is simply empty. + * + * This approach works because: + * - Tag search uses the API's tag_prefix filter (server-side, efficient). + * - Direct order value entry works by navigating to the order detail URL. + * - No need to load all orders client-side. + * + * Note: The API does NOT support filtering by order value prefix — only by + * tag and tag_prefix. So the autocomplete only surfaces tag-matching orders. + * For order-value lookup, the user types the full value and presses Enter. + * + * Returns an object with `destroy()` for cleanup and `setSuggestions()` for + * updating the suggestions list after render (e.g., once scaffold data is ready). + */ +export function renderOrderSearch( + container: HTMLElement, + options: OrderSearchOptions, +): { destroy: () => void; setSuggestions: (s: OrderSuggestion[]) => void } { + // ... implementation +} +``` + +### 2.3 Dashboard Page + +**File**: `lnt/server/ui/v5/frontend/src/pages/dashboard.ts` + +```typescript +// pages/dashboard.ts + +import type { PageModule, RouteParams } from '../router'; +import type { OrderDetail } from '../types'; +import { getRecentRuns, getOrder } from '../api'; +import { el, spaLink, formatTime, truncate, primaryOrderValue } from '../utils'; +import { renderDataTable } from '../components/data-table'; + +export const dashboardPage: PageModule = { + mount(container: HTMLElement, params: RouteParams): void { + const ts = params.testsuite; + container.append(el('h2', { class: 'page-header' }, 'Dashboard')); + + const recentSection = el('div', { class: 'dashboard-section' }); + container.append(recentSection); + + loadRecentOrders(ts, recentSection); + }, +}; +``` + +**Recent Orders section**: Fetches `getRecentRuns(ts, { limit: 50, sort: '-start_time' })`, groups runs by primary order field value, deduplicates to unique orders, and tracks the latest run UUID per order. Then batch-fetches `getOrder(ts, value)` for each unique order (typically <20 after dedup) to get their tags. Displays a two-column data table: **Order** (order value with tag suffix when set, e.g. "abc123 (release-18)", linked to Order Detail via `spaLink`) and **Latest Run** (timestamp linked to Run Detail via `spaLink`). + +The dashboard is intentionally minimal — just the Recent Orders table. Machine List and Field Change Triage are accessible from the navbar; separate dashboard sections for them added no value. + +### 2.4 Machine List Page + +**File**: `lnt/server/ui/v5/frontend/src/pages/machine-list.ts` + +- Renders a search input (name filter) and a data table +- Calls `getMachines(ts, { nameContains, limit, offset })` with offset pagination +- Table columns: Name (link to Machine Detail via `spaLink`), Info (key fields), Last Run (fetched lazily or omitted initially) +- Uses `renderDataTable` from `components/data-table.ts` +- URL state: `?search=` for the name filter (use `replaceState` on input change) +- All internal links use `spaLink()` from `utils.ts` for SPA navigation (no full page reloads) + +### 2.5 Machine Detail Page + +**File**: `lnt/server/ui/v5/frontend/src/pages/machine-detail.ts` + +- Reads `params.name` from the route +- Calls `getMachine(ts, name)` for metadata +- Calls `getMachineRuns(ts, name, { sort: '-start_time', limit: 25 })` for run history +- Displays: + - Machine name as heading + - Info key-value pairs as a definition list + - Run history table with columns: UUID (link to Run Detail), Order (link to Order Detail), Start Time + - Pagination controls for the run history table +- Action links: "Graph for this machine" (links to `/graph?machine={name}`), "Compare" (links to `/compare?machine_a={name}`) +- **Delete section** at the bottom (visually separated): + - "Delete Machine" button (red, danger style) + - Clicking shows a confirmation prompt: text input where the user must type the exact machine name, plus Confirm/Cancel buttons + - Confirm button stays disabled until the typed name matches exactly + - On confirm, calls `deleteMachine(ts, name)` (`DELETE /api/v5/{ts}/machines/{name}`, requires `manage` scope) + - While in-flight, shows "Deleting..." on the button and a message that deletion may take a while for machines with many runs + - On success (204), navigates to `/machines` + - On 401/403, shows an error message: "Permission denied. Set an API token with 'manage' scope in Settings." + - On other errors, shows the error message from the API + +### 2.6 Run Detail Page + +**File**: `lnt/server/ui/v5/frontend/src/pages/run-detail.ts` + +- Reads `params.uuid` from the route +- Calls `getRun(ts, uuid)` for run metadata and `getFields(ts)` for the metric selector in parallel +- Loads samples progressively via `fetchOneCursorPage()` in a loop (limit=2000 per page): + - Renders the table immediately with the first page + - Appends rows and re-renders as each subsequent page arrives + - Shows progress ("Loading samples: N...") + - Preserves current sort and filter state across re-renders +- Displays: + - Run UUID, machine (link), order (link), start/end time, parameters as metadata table + - Metric selector drop-down (reuses `renderMetricSelector` from `components/metric-selector.ts`) + - Test filter: text input (debounced 200ms) for case-insensitive substring matching on test names, with summary message showing filtered counts + - Samples table: Test name, selected metric value — sorted by test name ascending by default (using data-table's `sortKey`/`sortDir` options) + - The metric selector controls which metric column is shown +- Action links: "Compare with..." button (navigates to `/compare?machine_a={machine}&order_a={orderValue}`) +- **Delete section** at the bottom (same pattern as machine-detail.ts): + - "Delete Run" button (red, danger style) + - Confirmation: type first 8 chars of run UUID to confirm + - Calls `deleteRun(ts, uuid)` (requires `manage` scope) + - On success, navigates to the machine detail page + - On auth error, shows `authErrorMessage()` + +### 2.7 Order Detail Page + +**File**: `lnt/server/ui/v5/frontend/src/pages/order-detail.ts` + +- Reads `params.value` from the route +- Calls `getOrder(ts, value)` for order detail (includes prev/next links) +- Calls `getRunsByOrder(ts, value)` for runs at this order +- Displays: + - Order field values prominently + - **Tag display + editing**: Show the current tag (or "No tag") next to the order field values. An "Edit" button opens an inline text input (max 64 chars) with Save/Cancel buttons. Save calls `updateOrderTag(ts, value, newTag)` (requires `manage` scope token from Settings). On 401/403, shows auth error via `authErrorMessage()`. Setting the tag to empty string clears it (sends `null`). + - Prev/Next navigation buttons (using `previous_order`/`next_order` from the API response) + - Summary: "N runs across M machines" + - **Machine filter**: Text input for case-insensitive substring matching on machine names, debounced (200ms). Filters the runs table and updates the summary to reflect filtered counts (e.g., "5 of 12 runs across 2 of 8 machines"). + - Runs table: Machine (link to Machine Detail), Run UUID (link to Run Detail), Start Time + +### 2.8 Phase 2 Types + +**File**: `lnt/server/ui/v5/frontend/src/types.ts` (extend) + +Add the new interfaces listed in section 2.1: `OrderDetail`, `OrderNeighbor`, `RunDetail`, `TestInfo`, `QueryDataPoint`, `FieldChangeInfo`, `SchemaInfo`, `APIKeyInfo`. Also add `tag: string | null` to the existing `OrderSummary` interface. + +### 2.9 Phase 2 Testing + +**Unit tests per page module** (in `__tests__/pages/`): + +- **dashboard.test.ts**: Mock API calls, verify correct sections render, verify links to other pages +- **machine-list.test.ts**: Verify search filtering calls API with `name_contains`, verify table renders, verify click navigates +- **machine-detail.test.ts**: Verify metadata display, run history table, pagination +- **run-detail.test.ts**: Verify metadata, metric selector, samples table +- **order-detail.test.ts**: Verify order fields, prev/next navigation, machine filter, runs table + +**Tests for new API functions** (`__tests__/api.test.ts` — extend): + +- `getMachine`: correct URL, returns data +- `getMachineRuns`: correct URL with sort/limit/cursor params +- `getRun`: correct URL with UUID encoding +- `getOrder`: correct URL with order value encoding +- `getRunsByOrder`: correct URL with order filter +- `getTests`: correct URL with filter params +- `queryDataPoints`: correct URL with all filter combinations + +**Tests for data-table component** (`__tests__/data-table.test.ts`): + +- Renders columns and rows correctly +- Sort toggle works +- Row click callback fires +- Empty state message shows when no rows + +**Tests for pagination component** (`__tests__/pagination.test.ts`): + +- Renders Previous/Next buttons +- Buttons disabled state when hasPrevious/hasNext is false +- Click callbacks fire + +**Tests for order search component** (`__tests__/order-search.test.ts`): + +- Renders input field +- Debounced API call on keystroke (calls `searchOrdersByTag` with typed prefix) +- Dropdown shows results with order value + tag +- Enter key navigates to order detail URL +- Dropdown item click navigates to the selected order +- Suggestions mode: when `suggestions` are set, dropdown shows all suggestions on focus with tagged orders first +- Suggestions filtering: typing filters suggestions by prefix; red border appears when no matches; Enter is blocked in red-border state +- `setSuggestions()`: calling it after render updates the suggestions list + +**Tests for new API functions** (`__tests__/api.test.ts` — extend): + +- `searchOrdersByTag`: correct URL with `tag_prefix` param +- `updateOrderTag`: correct URL, PATCH method, JSON body with `tag` field, auth header + +--- + +## Phase 3: Graph Page + +**Goal**: Implement the time-series graph page with auto-plot (no Plot button), lazy-loaded Plotly line charts, per-metric client-side caching, test filtering, aggregation controls, and pinned order overlays. Data is fetched newest-first and rendered progressively so the chart appears immediately. + +### 3.1 Time Series Chart Component (`ChartHandle` API) + +**File**: `lnt/server/ui/v5/frontend/src/components/time-series-chart.ts` (new file) + +A Plotly-based line chart component for time-series data, designed for **incremental updates**. Distinct from the existing bar chart in `chart.ts` (which is for Compare). + +The key design choice is the `ChartHandle` pattern: instead of a one-shot `renderTimeSeriesChart()` function, the component exposes `createTimeSeriesChart()` which returns a handle. The handle's `update()` method calls `Plotly.react()` to update the chart in-place as new pages of data arrive, without destroying and re-creating the chart. This enables smooth progressive rendering during lazy loading. + +```typescript +// components/time-series-chart.ts + +declare const Plotly: { + newPlot(el: HTMLElement, data: unknown[], layout: unknown, config?: unknown): Promise; + react(el: HTMLElement, data: unknown[], layout: unknown, config?: unknown): Promise; + purge(el: HTMLElement): void; +}; + +export interface TimeSeriesTrace { + /** Test name (used for color assignment and filtering). */ + testName: string; + /** Machine name (used for marker symbol assignment and trace naming). */ + machine: string; + /** Plotly marker symbol for this trace's machine (e.g., 'circle', 'triangle-up'). */ + markerSymbol?: string; + /** Data points: [{ orderValue, value, runCount, timestamp }] sorted by order. */ + points: Array<{ + orderValue: string; + value: number; + runCount: number; + timestamp: string | null; + }>; +} + +export interface PinnedOrder { + orderValue: string; + /** User-assigned label, if any. */ + tag: string | null; + /** Per-test values at this pinned order. */ + values: Map; + /** Color for the pinned order lines. */ + color: string; +} + +export interface TimeSeriesChartOptions { + traces: TimeSeriesTrace[]; + /** Y-axis label (metric display name). */ + yAxisLabel: string; + /** Pinned orders to overlay as horizontal dashed lines. */ + pinnedOrders?: PinnedOrder[]; + /** + * Pre-fetched complete list of order values for the x-axis. + * When provided, sets Plotly's xaxis.categoryarray and + * xaxis.categoryorder = 'array' so the x-axis is fully established + * from the start and does not resize/shift as lazy-loaded pages arrive. + */ + categoryOrder?: string[]; + /** Lazy callback to get individual pre-aggregation values for a data point. + * Called on hover with (testName, machine, orderValue); if >1 values, + * a scatter is shown. */ + getRawValues?: (testName: string, machine: string, orderValue: string) => number[]; +} + +/** + * Handle for an active time-series chart. Supports incremental updates + * via Plotly.react() — the chart is updated in-place as new data arrives. + */ +export interface ChartHandle { + /** Re-render the chart with updated options (uses Plotly.react). */ + update(options: TimeSeriesChartOptions): void; + /** Highlight an entire trace by its trace name ('{testName} - {machine}'), + * dimming all others. Uses Plotly.restyle() to set opacity and line width — + * the hovered trace gets full opacity and a thicker line (3px), while all + * other main traces are dimmed to 0.2 opacity. Passing null restores all + * traces to their normal appearance. Pinned-order traces are + * dimmed along with non-hovered main traces. */ + hoverTrace(traceName: string | null): void; + /** Clean up the chart (calls Plotly.purge). */ + destroy(): void; +} + +/** + * Create a time-series line chart and return a handle for incremental updates. + * X-axis: order values (categorical). Y-axis: metric values. + * One trace (line) per test. + * + * Initial render uses Plotly.newPlot(). Subsequent calls to handle.update() + * use Plotly.react() for efficient in-place updates as lazy-loaded pages arrive. + */ +export function createTimeSeriesChart( + container: HTMLElement, + options: TimeSeriesChartOptions, +): ChartHandle { + // Build one Plotly trace per test×machine combination: + // { x: orderValues[], y: metricValues[], name: '{testName} - {machine}', + // mode: 'lines+markers', marker: { symbol: trace.markerSymbol } } + // + // Trace naming: each trace's Plotly name is '{testName} - {machine}'. + // Marker symbol: if trace.markerSymbol is set, it is passed through to + // Plotly's marker.symbol property. This distinguishes machines visually + // (circle for machine 1, triangle-up for machine 2, etc.) while colors + // represent test identity. + // + // If options.categoryOrder is provided, set layout.xaxis.categoryarray + // and layout.xaxis.categoryorder = 'array' so the x-axis is fixed from + // the start and does not resize/shift as lazy-loaded data pages arrive. + // Also set xaxis.autorange = false and xaxis.range = [-0.5, len - 0.5] + // to lock the visible range, since Plotly's autorange ignores null + // y-values in the scaffold and would shrink the axis otherwise. + // + // Pinned orders: rendered as actual Plotly traces (not layout shapes) + // so they support hover tooltips. Each pinned order line is a scatter + // trace with mode='lines', dash='dot', and showlegend=false, + // populated with a data point at every x-category (scaffold or all + // trace x-values as fallback) so that hover detection works anywhere + // along the line. The hovertemplate shows: pinned order value (with + // tag if set), test name, and metric value. Using traces instead of + // shapes avoids the Plotly issue where shapes on category axes + // require numeric indices rather than category name strings for x0/x1. + // + // Hover template: test name, machine name, order value, metric value, run count. + // Hover distance: set layout.hoverdistance = 5 for less sticky tooltips. + // + // Raw value scatter on hover: when `getRawValues` callback is provided + // in options, `plotly_hover` calls it with (testName, orderValue) to + // lazily fetch the individual pre-aggregation values. If >1 values are + // returned, a temporary scatter trace is added via Plotly.addTraces() + // showing the individual values at the same x-position, using the same + // trace color at 0.3 opacity, mode 'markers', showlegend false. The + // temporary trace is tracked via `scatterTraceIndex` and removed on + // `plotly_unhover` via Plotly.deleteTraces(). Both operations are + // chained after `plotReady`. The callback reference is stored and + // updated on each doPlot() call so it always reflects the latest options. + // + // Zoom preservation: buildPlotlyData() always produces the canonical + // layout with the full scaffold x-axis range. On react() calls (not + // the initial newPlot()), doPlot() reads the current axis state from + // chartDiv.layout (a documented Plotly API) and applies it to the + // new layout before passing it to react(). Importantly, the read + // must happen inside the plotReady.then() callback (not at the top + // of doPlot()), since chartDiv.layout may not reflect the correct + // state until the previous newPlot()/react() has resolved. + // - X-axis: always preserve chartDiv.layout.xaxis.range and + // xaxis.autorange. The x-axis range was established by the + // scaffold on initial render, or narrowed by user zoom — either + // way it should not change on data updates. + // - Y-axis: check chartDiv.layout.yaxis.autorange. If false, the + // user has explicitly zoomed (Plotly sets autorange=false and an + // explicit range on drag-zoom), so preserve the range. If true + // (or undefined), the chart is auto-ranging — don't set an + // explicit range, letting Plotly auto-fit to new data as it + // arrives during progressive loading. + // Double-click zoom reset works naturally: Plotly internally sets + // autorange=true on both axes, so the next react() call sees + // autorange=true and lets both axes auto-range again. + // When categoryOrder is not provided (scaffold unavailable), the + // same logic applies: Plotly's default autorange=true is preserved + // until the user zooms. + // + // Empty chart annotation: when traces are empty but categoryOrder is set, + // add a Plotly annotation at paper coordinates (0.5, 0.5) with text + // "No data to plot". This preserves the x-axis scaffold so the user + // can see the order range even when no data matches the current filter. + // + // newPlot/react race fix: the initial render stores Plotly.newPlot()'s + // return value as a `plotReady` promise. Subsequent calls to + // handle.update() chain Plotly.react() after `plotReady` resolves, + // preventing race conditions if update() is called before newPlot() + // completes. + // + // Returns a ChartHandle whose update() method rebuilds traces from new + // options and calls Plotly.react() to update in-place. + // ... +} +``` + +### 3.2 `fetchOneCursorPage` API Function + +**File**: `lnt/server/ui/v5/frontend/src/api.ts` (extend existing) + +Add a low-level cursor-pagination helper alongside the existing `queryDataPoints`: + +```typescript +export interface CursorPageResult { + items: T[]; + nextCursor: string | null; +} + +/** + * Fetch a single page of cursor-paginated results. + * Unlike fetchAllCursorPages, the caller controls limit and cursor via params. + * + * Used by the graph page for progressive loading: fetch newest data first, + * render immediately, then fetch older pages in the background. + */ +export async function fetchOneCursorPage( + url: string, + params?: Record, + signal?: AbortSignal, +): Promise> { + const page = await fetchJson>(url, params, signal); + return { items: page.items, nextCursor: page.cursor.next }; +} +``` + +This function is generic and URL-agnostic — it takes a full URL (built via `apiUrl()`) and an arbitrary params record. The graph page calls it with `apiUrl(ts, 'query')` and params like `{ machine, metric, sort: '-order', limit: '10000' }`, as well as with `apiUrl(ts, 'machines/{name}/runs')` for the scaffold fetch. + +### 3.3 Graph Page Module + +**File**: `lnt/server/ui/v5/frontend/src/pages/graph.ts` + +The graph page is the most data-intensive page. It uses **lazy loading with per-metric client-side caching** to deliver a fast, interactive experience. + +1. **Controls section** (top, wrapped in a `.controls-panel` box — same shared style as the Compare page's selection panel): + - Machine chip input: uses `renderMachineCombobox` from `components/machine-combobox.ts` for typeahead. When the user types a machine name and presses Enter, the machine is added to a `machines: string[]` list and a chip is rendered. Each chip has an × button to remove it. Adding or removing a machine triggers `doPlot()` if a metric is also selected. The machine list is always restored from URL params on mount (URL is the source of truth); the per-metric data cache is preserved at module scope so navigating back renders instantly. + - Metric selector drop-down (uses `renderMetricSelector` from `components/metric-selector.ts`). Rendered with `placeholder: true` so it initially shows "-- Select metric --" with no metric pre-selected, consistent with the Compare page. Accepts an optional `initialValue` parameter to pre-select the metric from URL state. When changed (`onChange` callback), if at least one machine is selected, auto-triggers `doPlot()`. + - "Filter tests" text input (label and placeholder consistent with Compare page, substring match, debounced 200ms). Matches on **test name only** (not machine name), showing/hiding the test across all machines simultaneously. Changes re-render from cache via `updateUrlState()` — no refetch. + - Run aggregation drop-down (median/mean/min/max) in a labeled control group ("Run aggregation"), consistent with Compare's layout. Changes re-render from cache via `updateUrlState()`. + - Sample aggregation drop-down (median/mean/min/max) in a separate labeled control group ("Sample aggregation"). Changes re-render from cache via `updateUrlState()`. + - Pinned order input (label: "Pinned Orders", placeholder: "Pin an order..."). Uses `renderOrderSearch` from `components/order-search.ts` in **suggestions mode** — `suggestions` is always passed (as `cachedSuggestions ?? []`), so the API fallback is never triggered. The suggestions are built from the **union** of all machines' scaffold order values combined with tags from `getOrders()` (fetched in parallel with the scaffolds), and cached at module scope (`cachedSuggestions`). `cachedSuggestions` is rebuilt when machines are added or removed. On focus, the suggestions dropdown shows all orders with tagged orders listed first. Typing filters suggestions by prefix matching. A red border appears when the typed value has no prefix matches; Enter is blocked for invalid values. Adding or removing a pinned order calls `updateUrlState()` — no refetch. + - No "Plot" button. Plotting is triggered automatically when at least one machine and a metric are selected. + +2. **Data fetching strategy — lazy loading with progressive rendering**: + - On `doPlot()` (called automatically when the machine list and metric are both non-empty): + - For **each machine** in the `machines` list, independently: + - Check the **per-metric client-side cache** (keyed by `machine::metric`). If the cache has data for this combination, use it immediately — no API call needed. + - If no cache hit, proceed in three sequential steps per machine: + 1. **X-axis scaffold** (if not already cached for this machine): Paginated calls to `GET machines/{name}/runs` (via `fetchOneCursorPage` with `sort=order`) to fetch the complete list of order values. In parallel, `getOrders(ts)` is called to obtain tags for the pinned-order suggestions dropdown. The scaffold is cached per machine. + 2. **Compute union scaffold**: The x-axis scaffold passed to the chart is the **union** of all machines' scaffolds (preserving order). This is recomputed whenever a machine is added/removed or a scaffold finishes loading. + 3. **Lazy data loading**: Begin fetching data pages via `fetchOneCursorPage(apiUrl(ts, 'query'), { machine, metric, sort: '-order', limit: '10000' })`. After each page, merge into that machine's cache and call `renderFromCache()` to update the chart with traces from **all** machines. + - Show a progress indicator during background fetching (e.g., "Loading: clang-x86 30000 points, gcc-arm 15000 points..."). + - **Per-machine×metric AbortControllers**: Each machine×metric fetch gets its own `AbortController`. Removing a machine aborts its in-flight fetch without affecting other machines. + - `renderFromCache()` iterates over all machines' caches, builds traces for each machine (with `machine` field and `markerSymbol` set), merges them, and passes the combined trace list to the chart. + - `buildTraces()` is called per machine with an empty text filter to get ALL tests. The active set is computed by `computeActiveTests()` based on trace names ("`{test} - {machine}`"), the text filter (matching test name only), manual toggles, and auto-cap. + - **Marker symbol assignment**: A fixed ordered list of Plotly marker symbols (`MACHINE_SYMBOLS = ['circle', 'triangle-up', 'square', 'diamond', 'x', 'cross', 'star', ...]`). The i-th machine in the `machines` list gets `MACHINE_SYMBOLS[i % MACHINE_SYMBOLS.length]`. + - **Color assignment**: Colors are assigned by alphabetical index of all **test names** (not trace names) across all machines, using the D3 category10 palette. This ensures the same test on different machines shares the same color. + +3. **Legend table and visibility control**: + - A `createLegendTable` component (`components/legend-table.ts`) renders below the chart, listing traces sorted alphabetically by name. The table is part of the normal page flow (no `max-height`, no `overflow` — scrolling the table scrolls the page, consistent with the Compare page's table) but has a border for visual grouping. Each row represents one trace and shows: a colored marker symbol character (●, ▲, ■, etc. in the trace's color), the test name (left-justified), and the machine name (right-justified, grey). Tests not matching the text filter are hidden entirely (filter matches test name only, hiding all machine variants of non-matching tests). Inactive traces (manually hidden or beyond the 20-cap) are grayed out in place (not partitioned below active traces). + - The legend message area above the table rows always shows a count: when the 20-cap is active, it shows the cap warning (e.g., "Showing first 20 of 150 traces..."); otherwise it shows a matching count (e.g., "42 of 150 traces matching"). When all traces are visible, it shows just the total (e.g., "150 traces"). + - A trace is active if: its test name matches the text filter, it has not been manually hidden, and (when the 20-cap is active) it is within the first 20 candidates. + - The 20-cap is only active when there is no text filter AND no manual toggles. Typing in the filter or clicking any row permanently disables the cap for the rest of the page session. + - Clicking a row toggles visibility and triggers `renderFromCache()`. Double-clicking a row is a shortcut for hiding all other visible traces: the `onIsolate` callback populates `manuallyHidden` with all visible trace names except the double-clicked one. If the double-clicked trace is already the only non-hidden trace, `manuallyHidden` is cleared to restore all. This uses the same `manuallyHidden` mechanism as single-click, so subsequent single-clicks work naturally (e.g., single-clicking a hidden trace after a double-click simply unhides it). The click/dblclick interaction is handled with a 200ms delay on single-click to prevent spurious toggles during a double-click. The legend table exposes both `onToggle` and `onIsolate` callbacks. + - Colors are assigned by alphabetical index of all **test names** (not trace names) using the D3 category10 palette (`PLOTLY_COLORS`), ensuring the same test on different machines shares the same color. + - Plotly's built-in legend is disabled (`showlegend: false` always). Traces receive explicit `line.color` and `marker.color` from the color map, and `marker.symbol` from the machine symbol assignment. + - Bidirectional hover: the legend table dispatches `GRAPH_TABLE_HOVER` events; the chart dispatches `GRAPH_CHART_HOVER` events. The graph page wires these via `onCustomEvent()` (which now returns a cleanup function) to call `chartHandle.hoverTrace()` and `legendHandle.highlightRow()` respectively. `hoverTrace()` uses `Plotly.restyle()` to emphasize the entire trace line (line width 3px, opacity 1.0) and dim all other main traces (opacity 0.2) and pinned-order traces. Passing `null` restores all traces to their normal appearance (line width 1.5px, opacity 1.0). The restyle calls are chained after `plotReady` to avoid race conditions with newPlot/react. + - `manuallyHidden` (Set of trace names — `'{test} - {machine}'`), `autoCapped` (boolean), `prevActiveTraceNames` (`Set` — the active set from the last chart render, used to skip no-op chart updates), and `legendHandle` are module-scope state. They are preserved across unmount/remount (like the cache). `computeActiveTests()` takes four inputs (allTraceNames, testFilter, manuallyHidden, autoCapped) and returns the active set. The test filter matches against the **test name portion** of each trace name. Double-click isolation is implemented purely through `manuallyHidden` — no separate `isolatedTest` state. + +3. **Per-metric client-side cache**: + - Cache structure: `Map` where the key is `${machine}::${metric}` and the value holds the accumulated data points, the next cursor (if fetching is still in progress), and whether fetching is complete. Each machine's data is cached independently. + - Cache is populated incrementally as pages arrive for each machine. + - **Instant interactions from cache**: When the user changes the test filter, aggregation mode, or pinned orders, the page re-processes all machines' cached data — no API call, no loading spinner. This is the primary UX benefit of the caching architecture. The `renderFromCache()` function accepts a `batch` parameter and is split into two phases: + - **Synchronous phase** (legend table + progress): For each machine, extract test names from its cache. Compute trace names (`{test} - {machine}`), compute active set, build legend entries, and update the legend table. This is cheap DOM work and provides instant feedback (e.g., showing which tests match while the user types a filter). + - **Deferred chart update phase**: For each machine, build traces with the machine's `markerSymbol`. Merge all machines' traces into a single list, then feed to the chart via `requestAnimationFrame`. **Before scheduling any chart work, compare the new active trace name set to `prevActiveTraceNames` (a module-scope `Set`). If the sets are identical and no new data has arrived (`batch = true` indicates a user-initiated change, not a data update), skip the entire deferred phase — the chart already shows the correct traces.** When the chart does need updating, the behavior depends on the `batch` parameter: + - **`batch = true`** (user-initiated changes: filter, toggle, aggregation, pinned orders): Traces are fed in **batches of `CHART_BATCH_SIZE` (10)** per animation frame. This batching exists to prevent the browser from freezing when a filter matches thousands of tests and the 20-cap is disabled — the chart achieves eventual consistency while the UI stays responsive. + - **`batch = false`** (progressive data loading: new pages arriving from the API): All traces are rendered in a **single deferred `requestAnimationFrame` call**. + - In both modes, a module-scope `chartRenderGen` generation counter ensures stale render sequences are abandoned. A `pendingChartRAF` ID is also tracked so the pending frame can be canceled on `unmount()`. Pinned orders are included in every update so pinned-order lines appear from the first frame. + - **Cache persists across navigation**: The per-machine data cache and scaffolds are module-scope variables that survive `unmount()`/`mount()` cycles. When the user navigates away and presses browser back, `doPlot()` finds the cached data and renders instantly. In-flight fetches are aborted on unmount (their `finally` blocks reset `entry.loading = false`), so `startLazyLoad()` resumes from the saved `nextCursor` on remount. A machine's cache is cleared when that machine is removed from the chip list. Module-scope UI state (`manuallyHidden`, `autoCapped`, `prevActiveTraceNames`, `chartRenderGen`, `cachedSuggestions`) is reset on unmount to prevent stale state on remount — the machines list is restored from URL params. + +4. **Pinned orders — asynchronous fetch with aggregation**: + - Pinned orders are fetched **after the first chart render**, so they do not block initial display. + - For each machine, check if the pinned order's data points are already in that machine's cache. If so, extract them directly. If not (e.g., the pinned order is outside the fetched range), make a targeted call per machine: `queryDataPoints(ts, { machine, metric, afterOrder: ref, beforeOrder: ref })`. + - **Aggregation consistency**: Pinned order Y values must be computed using the same run aggregation function (`runAgg`) as the main traces. When multiple data points exist for the same test at the pinned order (multiple runs), they are collected and aggregated, not just taking the first value. The `buildRefsFromCache` function receives the `runAgg` function and applies it per test, so the pinned dashed line aligns exactly with the trace point at that order. + - Once pinned order data is available, call `chartHandle.update()` to overlay the dashed lines. + +5. **Chart rendering**: + - For each machine: group data points by test name and order, apply aggregation, produce `TimeSeriesTrace[]` with `machine` and `markerSymbol` fields set + - Merge all machines' traces into a single list, sorted alphabetically by trace name (`{test} - {machine}`) + - Pass to `createTimeSeriesChart()` (initial) or `chartHandle.update()` (incremental) + +6. **URL state**: + - `?machine={name}&machine={name2}&metric={name}&test_filter={text}&run_agg={fn}&sample_agg={fn}&pin={order1}&pin={order2}` + - The `machine` parameter is repeated for each selected machine. On mount, parse all `machine` values from URL params and populate the chip list. + - On mount, parse URL params and auto-plot if machines and metric are provided. The metric selector uses `initialValue` to pre-select the URL metric. The chart container is initialized with a "No data to plot." message, which is replaced on the first successful plot. + - `updateUrlState()` is called from all interactive handlers (machine add/remove, test filter change, aggregation change, pinned order add/remove), not only from `doPlot()`. This ensures the URL always reflects the current UI state. + +### 3.4 Phase 3 Testing + +**Tests for `time-series-chart.ts`** (`__tests__/time-series-chart.test.ts`): +- `createTimeSeriesChart` returns a valid `ChartHandle` +- `ChartHandle.update()` calls `Plotly.react()` (not `newPlot`) for incremental updates +- Data preparation: verify traces are built correctly from input data +- Pinned orders: verify pinned-order traces (not shapes) are generated with correct y-values, dash style, color, `showlegend: false`, and hover template containing pinned order value, tag, test name, and metric value; verify scaffold x-range is used when `categoryOrder` is provided; verify no pinned-order traces are generated for tests not in the main traces +- X-axis scaffolding: verify that when `categoryOrder` is provided, the layout sets `xaxis.categoryarray` and `xaxis.categoryorder = 'array'`; verify that when `categoryOrder` is omitted, these layout properties are not set +- Marker symbols: verify that `markerSymbol` on `TimeSeriesTrace` is passed through to Plotly's `marker.symbol` +- Trace naming: verify that the Plotly trace name is `{testName} - {machine}` +- Empty chart annotation: verify that when traces are empty and `categoryOrder` is set, a Plotly annotation is added at paper coordinates (0.5, 0.5) with "No data to plot" +- `plotReady` promise: verify that `update()` chains `Plotly.react()` after the `plotReady` promise from `newPlot()`, preventing race conditions +- `ChartHandle.destroy()` calls `Plotly.purge()` +- Trace highlighting via `hoverTrace()`: verify that `hoverTrace(testName)` calls `Plotly.restyle()` to set the hovered trace to opacity 1.0 and line width 3, while dimming all other traces to opacity 0.2; verify that `hoverTrace(null)` restores all traces to opacity 1.0 and line width 1.5; verify that pinned-order traces are dimmed along with non-hovered main traces; verify restyle calls are chained after `plotReady` +- Raw value scatter: verify that when `getRawValues` returns >1 values, `Plotly.addTraces()` is called with a markers-only scatter trace at the hovered x-position; verify the scatter trace uses the same color at opacity 0.3; verify `Plotly.deleteTraces()` is called on unhover; verify no scatter trace is added when `getRawValues` returns ≤1 values; verify no scatter trace is added when `getRawValues` is not provided +- Zoom preservation: verify that `update()` passes the current `xaxis.range` and `xaxis.autorange` from `chartDiv.layout` to `Plotly.react()`, so x-axis zoom is preserved; verify that when `yaxis.autorange` is `false` on the chart div, the y-axis range is also preserved; verify that when `yaxis.autorange` is `true`, no explicit y-axis range is set (allowing auto-range); verify that after a zoom reset (both axes `autorange` set back to `true`), the next `update()` does not set explicit ranges + +**Tests for `fetchOneCursorPage`** (`__tests__/api.test.ts`): +- Returns data points and next cursor from a paginated response +- Returns `nextCursor: null` on the last page +- Passes abort signal through to fetch + +**Tests for `pages/graph.ts`** (`__tests__/pages/graph.test.ts`): +- Machine chip input: verify typing a machine name and pressing Enter adds a chip; verify × button removes it; verify removing the last machine clears the chart +- Auto-plot: verify `doPlot()` is called when a machine is added and metric is set; verify no Plot button element exists +- Multi-machine: verify that adding a second machine triggers its own fetch pipeline; verify traces from both machines appear in the chart options; verify trace names are `{test} - {machine}` format; verify marker symbols are assigned per machine index +- URL state parsing: verify multiple `machine` params are restored from URL; verify metric/filter/pinned orders are restored; verify metric selector receives `initialValue` from URL +- URL sync: verify `updateUrlState()` is called from machine add/remove, test filter, aggregation, and pinned order handlers; verify `machine` param is repeated for each selected machine +- Pinned orders: verify URL param is `pin` (not `ref`); verify label is "Pinned Orders" and placeholder is "Pin an order..."; verify pinned order Y values use the same run aggregation as main traces (not just the first raw value) +- Order search suggestions: verify suggestions are populated from union of all machines' scaffolds + `getOrders()` (tags), with tagged orders first; verify prefix-based filtering; verify red border on no matches and Enter blocked +- Test filter: verify filter matches test name only (not machine name); verify matching test shows all machine variants; verify non-matching test hides all machine variants +- Color assignment: verify colors are assigned by alphabetical index of test names (not trace names); verify same test on different machines gets the same color +- Test cap warning: verify warning shows when > N traces match +- Aggregation: verify data points are correctly aggregated before charting +- Cache hit: verify that changing test filter re-renders from cache without API call +- Skip-no-op: verify that `setsEqual` returns true for identical sets and false for different sets; verify that the chart update is skipped when the active trace set has not changed (batch=true path only) +- Cache miss: verify that a new machine triggers a fetch for that machine only +- Progressive rendering: verify `chartHandle.update()` is called after each page, with traces from all machines +- AbortController: verify that removing a machine aborts its in-flight fetch without affecting other machines +- X-axis scaffold: verify the machine runs endpoint is called per machine; verify scaffold union is passed as `categoryOrder` to the chart; verify scaffold is cached per machine; verify chart still renders if one machine's scaffold fetch fails +- `computeActiveTests`: 20-cap with no filter, filter disables cap, manuallyHidden excludes traces, cap disabled when manuallyHidden non-empty, cap never re-enabled + +**Tests for `legend-table.ts`** (`__tests__/legend-table.test.ts`): +- Rows rendered in entry order with inactive rows grayed out (no partitioning) +- Colored symbol shows correct color and defaults to ● when no symbolChar specified +- Single-click calls `onToggle` (after 200ms delay) +- Double-click calls `onIsolate` without triggering `onToggle` +- `update()` replaces table content +- `highlightRow()` adds/removes highlight class +- `GRAPH_TABLE_HOVER` events dispatched on hover +- `destroy()` removes the table + +--- + +## Phase 4: Compare Integration + +**Goal**: Absorb the existing Compare page into the SPA as a page module, add geomean summary row, and support pre-selected side A from URL params. + +### 4.0 Existing Implementation (what's already built) + +The Compare page was the first v5 frontend page and is already functional as a standalone SPA. This section summarizes what exists before Phase 4 changes. See the Compare section of `docs/design/v5-ui.md` for the full design. + +**Modules**: +- `comparison.ts` — Core comparison logic: aggregation (within-run, across-runs), delta/ratio/status computation, `bigger_is_better` handling, zero-baseline and null-metric edge cases +- `selection.ts` — Renders the selection panel: per-side order/machine comboboxes, runs checkbox list, run/sample aggregation dropdowns, metric selector, noise threshold, test filter, hideNoise checkbox +- `table.ts` — Renders the comparison table: columns (Test, Value A/B, Delta, Delta %, Ratio, Status), sortable headers, color-coded status, noise de-emphasis, missing-test section, chart-zoom filtering +- `chart.ts` — Sorted ratio chart via Plotly: X=tests sorted by ratio, Y=percent change from baseline `(ratio - 1) * 100` on a **linear scale** (not log scale), connected line, noise band reference lines, hover tooltips, zoom/drag-select that filters the table +- `combobox.ts` — Searchable dropdown widget used for order and machine selection, with typeahead filtering +- `state.ts` — URL state management: encode/decode all selection params (`order_a`, `machine_a`, `runs_a`, `run_agg_a`, etc.), `replaceState`-based URL sync +- `events.ts` — Custom event system for chart-table sync (`CHART_ZOOM`, `CHART_HOVER`, `TABLE_HOVER`, `SETTINGS_CHANGE`, `TEST_FILTER_CHANGE`) + +**Data flow**: On load, fetches metric metadata (`GET test-suites/{ts}`) and all orders (`GET orders`, cursor-paginated). On order+machine change per side, fetches runs. On comparison trigger, fetches samples per run (`GET runs/{uuid}/samples`). All subsequent interactions (filter, sort, zoom) are client-side. + +### 4.1 Refactoring Existing Modules + +The existing Compare code is spread across `comparison.ts`, `selection.ts`, `table.ts`, `chart.ts`, `combobox.ts`, `state.ts`, and `events.ts`. These modules are well-structured and mostly decoupled from `main.ts`. + +**Strategy**: The existing modules remain as-is (they are shared utilities), with adjustments to `selection.ts`, `chart.ts`, and `state.ts`: + +**`state.ts` changes:** +- `setState()`, `setSideA()`, and `setSideB()` automatically call `replaceUrl()` after mutating state, so the URL always reflects the current UI state immediately — callers don't need to manage URL updates explicitly. All URL updates use `replaceState` (never `pushState`) so the browser Back button navigates between pages, not between individual setting changes within a page. +- `swapSides()` exchanges `sideA` and `sideB` in the global state and calls `replaceUrl()`. Used by the swap button in the selection panel. + +**`selection.ts` changes:** +1. **Remove the Settings panel** (toggle button + token input) from `renderSelectionPanel()` — the SPA nav bar already provides the Settings panel with the API token input, so duplicating it on the Compare page is unnecessary. Also **remove the Compare button** — comparison is now auto-triggered via `tryAutoCompare()` whenever state is valid (both sides have runs + metric selected). `tryAutoCompare()` is called from: `createRunsPanel` (runs loaded or checkbox changed), metric select change, run agg change, sample agg change. +2. **Always select all runs by default** in `createRunsPanel()`: all available runs are checked by default. The only exception is URL state restoration: if the URL contains `runs_a` or `runs_b` UUIDs that match available runs, that selection is restored (allowing shared URLs to preserve a specific run subset). When no URL runs match (fresh load, order change), all runs are selected. +3. **Metric selector uses shared component**: Replace the inline `createMetricSelect()` with the shared `renderMetricSelector` from `components/metric-selector.ts` (with `placeholder: true`). The `getMetricFields()` function uses `filterMetricFields()` from the shared component to filter by `type === 'Real'` (consistent with all other pages). The `onChange` callback calls `setState({ metric })` then `tryAutoCompare()`. +4. **Swap sides button**: A circular button (⇄) between the two side panels in the `.sides-row`. Clicking it calls `swapSides()` from `state.ts`, re-renders the selection panel, and triggers `tryAutoCompare()`. This lets users quickly reverse the baseline/new direction. + +**`chart.ts` changes:** +3. **Apply text filter to chart**: `drawChart()` reads `state.testFilter` and applies it as an additional filter on top of the chart zoom filter (`filterTests`). When both are active, their intersection is used. This ensures the chart only shows tests matching the text filter. +4. **Add `refreshChart()` export**: Redraws the chart using the last-used zoom filter (stored in module-scope `lastFilterTests`). Called by the compare page on `TEST_FILTER_CHANGE` and `SETTINGS_CHANGE` events to update the chart without losing the current zoom state. +5. **Remove `hideNoise` from `prepareChartData`**: Visibility is now controlled entirely by the compare page via `manuallyHidden`. The compare page passes only visible rows to the chart, so `prepareChartData` no longer needs to filter by noise status. The `hideNoise` parameter is removed. + +**`table.ts` changes:** +6. **Interactive row toggling**: `renderTable` accepts an optional `TableOptions` with `hiddenTests: Set`, `onToggle: (test) => void`, and `onIsolate: (test) => void`. Hidden rows are shown grayed out (not removed). Click/dblclick handlers on rows use a 200ms delay (same pattern as the Graph page's legend table) to distinguish single-click (toggle) from double-click (isolate). Double-clicking isolates among **currently-visible rows** (those matching the text filter), consistent with the Graph page's legend behavior. The internal `hideNoise` filtering is removed from `redraw()` — this is now handled by the compare page via `hiddenTests`. +7. **Table summary message**: `redraw()` adds a message div above the table showing counts: "N tests" (all visible), "M of N tests visible" (some hidden), or "M of N tests matching" (text filter or zoom active). Consistent with the Graph page's legend message. + +**`chart.ts` changes (continued):** +8. **`preserveZoom` parameter on `renderChart`**: `renderChart(container, rows, preserveZoom?)` accepts an optional `preserveZoom` flag (default `false`). When `true`, the chart redraws with the last-used zoom filter (`lastFilterTests`) instead of resetting to `null`. Used by the compare page for all re-renders (settings changes, toggles, filters) so zoom is preserved. + +**`pages/compare.ts` changes:** +9. **`manuallyHidden: Set`** at module scope. The compare page manages visibility: toggle adds/removes from the set; isolate hides all others (or restores if the target is the only visible test). `hideNoise` is a separate filter applied on top — a test is hidden if it's in `manuallyHidden` OR (its status is 'noise' AND `state.hideNoise` is true). The two filters are independent: manual toggles persist across hideNoise changes. The effective hidden set is computed by `computeEffectiveHidden()` and passed to both the table (for graying out rows) and the chart (by filtering rows before passing them). All chart updates use `preserveZoom: true`. + +**`combobox.ts` changes:** +10. **Order tags in dropdown**: `ComboboxContext` gains an `orderTags: Map` field (built from `cachedOrders` in `selection.ts`). The order dropdown displays tags alongside values (e.g., "abc123 (release-18)") and the text filter matches against both the order value and the tag. +11. **Machine-filtered orders**: When a machine is selected but its orders haven't loaded yet (`machineOrders` is null), the dropdown shows "Loading orders..." instead of unfiltered results. On combobox creation, if a machine is pre-selected from URL state, `fetchMachineOrders` is called immediately so the dropdown is correctly filtered from the start. +12. **Per-side abort controllers**: `fetchMachineOrders` uses per-side abort controllers (`machineOrdersControllerA`/`B`) instead of a single shared one, so fetching orders for side B doesn't abort side A's in-flight request. +13. **Abort controllers in reset**: `resetComboboxState()` aborts in-flight `machineOrdersControllerA`/`B` and `machineSearchController` requests. + +**File**: `lnt/server/ui/v5/frontend/src/pages/compare.ts` + +The compare page module implements: +- `mount()`: Renders a page header (`

Compare

`), restores URL state, fetches fields/orders, renders selection panel, wires event listeners (`CHART_ZOOM`, `CHART_HOVER`, `TABLE_HOVER`, `SETTINGS_CHANGE`, `TEST_FILTER_CHANGE`), auto-compare via `tryAutoCompare()` in selection.ts. The chart container is initialized with a "No data to chart." message (consistent with the Graph page's empty state), which is replaced on the first comparison. +- `unmount()`: Removes event listeners, aborts fetches, clears sample cache and `manuallyHidden`, calls `destroyChart()` and `resetTable()` +- `doCompare()`: Checks sample cache, fetches only uncached runs, evicts stale cache entries, calls `recomputeFromCache()` +- `recomputeFromCache()`: Aggregates from cached samples, computes comparison, renders table and chart +- `renderTableAndChart()`: Computes effective hidden set (`manuallyHidden` + hideNoise filter), passes visible rows to chart with `preserveZoom: true`, passes full rows + toggle/isolate callbacks to table +- `computeEffectiveHidden()`: Unions `manuallyHidden` with noise tests when `state.hideNoise` is true + +**Critical**: The `unmount()` function must: +- Abort in-flight fetch requests (via `AbortController`) +- Remove `document` event listeners (registered via `onCustomEvent()` which returns cleanup functions) +- Call `destroyChart()` from `chart.ts` (calls `Plotly.purge()` and clears module-level refs) +- Call `resetTable()` from `table.ts` (clears module-level container and row refs) + +### 4.2 Geomean Summary Row + +Add a computed geomean row to the comparison table showing aggregate values for both sides, their delta, and the ratio geomean. + +**File**: `lnt/server/ui/v5/frontend/src/comparison.ts` (extend) + +`computeGeomean(rows)` returns a `GeomeanResult` with: +- `geomeanA` / `geomeanB`: geometric mean of absolute values per side +- `delta`: `geomeanB - geomeanA` +- `deltaPct`: delta as percentage of geomeanA (null if geomeanA is 0) +- `ratioGeomean`: geometric mean of per-test ratios (the standard multiplicative average speedup) + +Rows with `status === 'na'`, null ratios, or null values are excluded. Returns null if no valid rows exist. + +**File**: `lnt/server/ui/v5/frontend/src/table.ts` (extend) + +The geomean row is the first row of the tbody, showing all columns filled: Value A (geomeanA), Value B (geomeanB), Delta, Delta %, Ratio (ratioGeomean). + +### 4.3 Pre-Selected Side A from URL + +When navigating from Machine Detail or Run Detail to Compare with a pre-selected machine and order on side A, the URL will contain `?machine_a={name}&order_a={value}`. + +This already works with the existing state management: `applyUrlState` in `state.ts` decodes `machine_a` and `order_a` from the URL and populates `state.sideA`. The selection panel renders with these values pre-filled. The user can then fill in side B and click Compare. + +No additional code is needed beyond ensuring the linking pages generate the correct URL params. + +### 4.4 Remove Old Compare Files + +After Phase 4 is complete and verified: + +1. Delete `v5_compare.html` (the old standalone template that extended `layout.html`) +2. Delete `static/comparison/` directory (the old standalone build output) +3. Remove the Compare link from the v4 navbar in `layout.html` — Compare is now only accessible via the v5 SPA + +Note: The old `v5_compare` route was already removed during Phase 1 (SPA scaffolding) — the catch-all route in `views.py` now handles `/v5/{ts}/compare`. + +### 4.5 Phase 4 Testing + +**Tests for `computeGeomean`** (`__tests__/comparison.test.ts`): +- Returns null for empty rows, missing rows, na rows +- Computes correct ratio geomean, geomeanA, geomeanB, delta, deltaPct +- Ignores rows with null ratio or a_only/b_only +- Single row: geomean equals the values +- All ratios = 1.0: ratio geomean = 1.0, delta = 0 + +**Tests for Compare page module** (`__tests__/pages/compare.test.ts`): +- Mount loads fields and orders +- Shows error when fetch fails +- Renders selection panel after data loads +- Unmount cleans up without errors +- Unmount is safe before mount completes + +**Tests for chart** (`__tests__/chart.test.ts`): +- `prepareChartData` filters, sorts, colors, customdata — updated to 2-parameter signature (no `hideNoise`) +- Noise rows included (visibility controlled by caller) +- `filterTests` combined with noise rows + +**Tests for table** (`__tests__/table.test.ts`): +- Geomean row with A/B values, delta, and ratio +- No geomean row when no valid ratios +- Hidden rows rendered with `row-hidden` class +- All rows shown including noise when `hiddenTests` is empty +- `onToggle` called on single click with 200ms delay +- `onIsolate` called on double-click without triggering `onToggle` + +**Tests for combobox** (`__tests__/combobox.test.ts`): +- Tags shown in dropdown items +- Filter matches by tag text and by order value +- Loading hint when machine set but orders not loaded +- `setSide` called with order value (not tag) on selection +- Tag shown in input after selection +- Tag shown in input on URL restore +- Plain value shown when order has no tag + +--- + +## Phase 5: Stub Pages + +**Goal**: Add placeholder pages for Regression List, Regression Detail, and Field Change Triage. + +### 5.1 Stub Pattern + +Each stub follows the same pattern: + +```typescript +import type { PageModule, RouteParams } from '../router'; +import { el } from '../utils'; + +export const regressionListPage: PageModule = { + mount(container: HTMLElement, params: RouteParams): void { + container.append( + el('div', { class: 'page-placeholder' }, + el('h2', {}, 'Regression List'), + el('p', {}, 'Not implemented yet.'), + el('p', {}, + 'This page will show detected regressions with filtering by state, ', + 'machine, test, and metric. Design coming in a later phase.' + ), + ) + ); + }, +}; +``` + +### 5.2 Stub Pages to Create + +- `pages/regression-list.ts` — "Regression List: Not implemented yet." +- `pages/regression-detail.ts` — "Regression Detail: Not implemented yet." (reads `params.uuid` for display) +- `pages/field-change-triage.ts` — "Field Change Triage: Not implemented yet." + +These were already registered in the router in Phase 1, so they are routable; they just show placeholder content. + +### 5.3 Phase 5 Testing + +No new unit tests needed beyond verifying the stubs render their placeholder text (covered by basic smoke tests in Phase 1). + +--- + +## Phase 6: Admin Page + +**Goal**: Implement the Admin page with API key management and schema viewer. The admin page is not test-suite specific — it is served at `/v5/admin`. + +### 6.1 Flask Route + +**File**: `lnt/server/ui/v5/views.py` + +A new route `/v5/admin` serves the SPA shell with `g.testsuite_name = ''`. The template conditionally renders the title and v4 URL based on whether a testsuite is set. + +### 6.2 SPA Bootstrap + +**File**: `lnt/server/ui/v5/frontend/src/main.ts` + +When `data-testsuite` is empty (admin-only context), the SPA sets `basePath = /v5` and only registers the admin route. The nav bar is still rendered with the full testsuites list. + +**File**: `lnt/server/ui/v5/frontend/src/components/nav.ts` + +The Admin link uses a regular `` (not SPA router navigation) so it works from any testsuite context and navigates to the global admin page. + +### 6.3 Admin Page Module + +**File**: `lnt/server/ui/v5/frontend/src/pages/admin.ts` + +The Admin page has three tabs: API Keys, Test Suites, and Create Suite. The page reads `data-testsuites` from the HTML root element to get the list of available test suites. A shared `activateTab()` helper manages the active tab state. + +- **API Keys tab** (default): Lists keys, create key form, revoke buttons. +- **Test Suites tab**: Suite selector dropdown, schema viewer (metrics + field tables), delete suite with double confirmation. +- **Create Suite tab**: Name input + JSON textarea. On success, switches to the Test Suites tab with the new suite selected. + +### 6.2 API Keys Tab + +Shows a table of existing API keys with columns: Prefix, Name, Scope, Created, Last Used, Active. Provides a "Create Key" form (name + scope select) and a "Revoke" button per active key. Created tokens display with a copy-to-clipboard button. Auth errors (401/403) show "Admin token required. Set your token in Settings." + +API calls: `GET/POST/DELETE /api/v5/admin/api-keys` (require `admin` scope). + +API functions in `api.ts`: `getApiKeys()`, `createApiKey(name, scope)`, `revokeApiKey(prefix)`. + +### 6.4 Test Suites Tab + +Displays the test suite schema definition and field metadata with a suite selector, plus delete functionality: + +**Suite selector + viewer**: +- A dropdown populated from `data-testsuites` lets the user switch between test suites +- Calls `getTestSuiteInfo(ts)` for the selected suite +- Shows metrics table: Name, Type, Display Name, Unit, Bigger is Better +- Shows order fields, machine fields, and run fields tables + +**Delete suite**: +- A "Delete This Suite" button below the schema viewer for the currently selected suite +- Clicking it reveals an inline confirmation panel with: + - Warning text: "Deleting test suite '{name}' will permanently destroy all machines, runs, orders, samples, regressions, and field changes. This cannot be undone." + - A text input where the user must type the exact suite name + - A red "Delete permanently" button, disabled until the typed name matches +- Calls `deleteTestSuite(name)` — wraps `DELETE /api/v5/test-suites/{name}?confirm=true` +- On success: refreshes the suite list, selects the first remaining suite +- Requires `manage` scope; shows auth error on 401/403 + +### 6.5 Create Suite Tab + +A standalone tab for creating new test suites: +- Name input for the suite name +- JSON textarea for the full schema definition (format_version, metrics, run_fields, machine_fields) +- The name input value overrides `name` in the JSON; `format_version` defaults to `"2"` if not set +- Calls `createTestSuite(payload)` — wraps `POST /api/v5/test-suites` +- On success: adds the suite to the local list and switches to the Test Suites tab with the new suite auto-selected +- Requires `manage` scope; shows auth error on 401/403 + +**API functions** in `api.ts`: +```typescript +createTestSuite(payload: object, signal?): Promise +deleteTestSuite(name: string, signal?): Promise +``` + +### 6.6 Phase 6 Testing + +**Tests for admin page** (`__tests__/pages/admin.test.ts`): +- Tab bar renders API Keys, Test Suites, and Create Suite tabs +- List keys renders table +- Create key form present +- 401/403 error shows auth message +- Revoke button only shown for active keys +- Suite selector with all suites, loads first suite automatically +- Schema renders metrics and field tables +- Create Suite tab shows name input and JSON textarea +- Delete suite shows confirmation with name-match input +- Delete button disabled until name matches + +--- + +## Cross-Cutting Concerns + +### URL State Management Pattern + +Each page manages its own URL state independently. The pattern: + +1. **On mount**: Parse `window.location.search` to restore page-specific state +2. **On user interaction**: Update state, call `replaceState` (for filter/sort changes) or `pushState` (for navigation-like changes) +3. **On popstate**: Re-parse URL and update the page + +The existing `state.ts` module handles Compare-specific state. Other pages should NOT use the global `state.ts` — instead, each page manages its own local state with its own URL param names. This avoids conflicts. + +**Recommended pattern for new pages**: + +```typescript +// Each page defines its own state interface and encode/decode functions +interface PageState { ... } + +function decodePageState(search: string): PageState { ... } +function encodePageState(state: PageState): string { ... } + +// On mount: +const state = decodePageState(window.location.search); + +// On state change: +const qs = encodePageState(state); +window.history.replaceState(null, '', window.location.pathname + (qs ? '?' + qs : '')); +``` + +### Error Handling and Loading States + +Every page should follow this pattern: + +1. **Loading**: Show "Loading..." text or a progress indicator while fetching data +2. **Error**: Catch API errors and display them using an inline error banner (e.g., a `div` with class `error-banner`) +3. **Empty state**: If the API returns empty results, show a meaningful message (e.g., "No machines found" rather than an empty table) + +Progress and error feedback is handled per-page using simple DOM containers (a `span.progress-label` for loading messages, a `div.error-banner` for errors), following the same pattern as the Graph page. + +### v4 Layout Toggle + +The v5 SPA is a standalone page (does not extend `layout.html`). The v5 nav bar includes a "v4 UI" link pointing to the v4 recent activity page for the current test suite. + +To add a "v5 UI" link in the v4 layout: + +**File**: `lnt/server/ui/templates/layout.html` (modify) + +In the test suite dropdown menu, add a link to the v5 UI: + +```html +
  • v5 UI
    • +``` + +This should be added near the existing "Compare" link in the suite dropdown. + +### Static Asset Serving + +The v5 SPA assets are served from the Flask blueprint's static folder: +- CSS: `/v5/static/v5/v5.css` +- JS: `/v5/static/v5/v5.js` +- Source maps: `/v5/static/v5/v5.js.map` + +The `v5_app.html` template references these via `url_for('lnt_v5.static', ...)`. + +After each build (`npm run build`), the compiled assets appear in `lnt/server/ui/v5/static/v5/`. These should be committed to the repository (same pattern as the current `static/comparison/` directory). + +### Navigation Between Pages + +All internal links must use the `spaLink()` utility (defined in section 1.8) instead of raw `` tags. This ensures SPA navigation without full page reloads. Every page module should import `spaLink` from `utils.ts` and use it for all links to other v5 pages. + +```typescript +// Usage in any page module: +import { spaLink } from '../utils'; + +const machineLink = spaLink(machineName, `/machines/${encodeURIComponent(machineName)}`); +``` + +--- + +## Testing Strategy + +### Unit Test Coverage Per Phase + +| Phase | Test Files | What to Test | +|-------|-----------|-------------| +| 1 | `router.test.ts`, `nav.test.ts` | Route matching, navigation, nav rendering, active link | +| 2 | `api.test.ts` (extend), `data-table.test.ts`, `pagination.test.ts`, `order-search.test.ts`, `pages/dashboard.test.ts`, `pages/machine-list.test.ts`, `pages/machine-detail.test.ts`, `pages/run-detail.test.ts`, `pages/order-detail.test.ts` | API function signatures and URL construction, component rendering, page mount/data flow | +| 3 | `time-series-chart.test.ts`, `pages/graph.test.ts` | Chart data preparation, aggregation, URL state | +| 4 | `comparison.test.ts` (extend), `pages/compare.test.ts` | Geomean computation, SPA integration, unmount cleanup | +| 5 | (minimal) | Stub rendering | +| 6 | `pages/admin.test.ts` | API key CRUD, schema display, auth error handling | + +### Testing Patterns + +All tests use Vitest (already configured). DOM tests use `@vitest-environment jsdom`. + +**API tests**: Mock `fetch` globally (same pattern as existing `api.test.ts`). Verify URL construction, param encoding, error handling. + +**Component tests**: Create a container div, call the render function, assert on DOM structure. + +**Page tests**: Mock API functions, call `page.mount(container, params)`, assert on rendered DOM and API call arguments. + +### Manual Verification Checklist (Per Phase) + +1. Build: `cd lnt/server/ui/v5/frontend && npm run build` +2. Tests: `npm test` +3. Start server: `lnt runserver` +4. Navigate to `http://localhost:8000/v5/{ts}/` +5. Verify all pages load without console errors +6. Verify SPA navigation (no full page reloads) +7. Verify browser back/forward +8. Verify direct URL access (bookmark) +9. Verify v4 UI is unaffected +10. Verify v4 <-> v5 toggle links + +--- + +## File Summary + +### New Files + +``` +lnt/server/ui/v5/templates/v5_app.html +lnt/server/ui/v5/frontend/src/router.ts +lnt/server/ui/v5/frontend/src/components/nav.ts +lnt/server/ui/v5/frontend/src/components/data-table.ts +lnt/server/ui/v5/frontend/src/components/pagination.ts +lnt/server/ui/v5/frontend/src/components/order-search.ts +lnt/server/ui/v5/frontend/src/components/machine-combobox.ts +lnt/server/ui/v5/frontend/src/components/time-series-chart.ts +lnt/server/ui/v5/frontend/src/pages/dashboard.ts +lnt/server/ui/v5/frontend/src/pages/machine-list.ts +lnt/server/ui/v5/frontend/src/pages/machine-detail.ts +lnt/server/ui/v5/frontend/src/pages/run-detail.ts +lnt/server/ui/v5/frontend/src/pages/order-detail.ts +lnt/server/ui/v5/frontend/src/pages/graph.ts +lnt/server/ui/v5/frontend/src/pages/compare.ts +lnt/server/ui/v5/frontend/src/pages/regression-list.ts +lnt/server/ui/v5/frontend/src/pages/regression-detail.ts +lnt/server/ui/v5/frontend/src/pages/field-change-triage.ts +lnt/server/ui/v5/frontend/src/pages/admin.ts +lnt/server/ui/v5/frontend/src/__tests__/router.test.ts +lnt/server/ui/v5/frontend/src/__tests__/nav.test.ts +lnt/server/ui/v5/frontend/src/__tests__/data-table.test.ts +lnt/server/ui/v5/frontend/src/__tests__/pagination.test.ts +lnt/server/ui/v5/frontend/src/__tests__/order-search.test.ts +lnt/server/ui/v5/frontend/src/__tests__/machine-combobox.test.ts +lnt/server/ui/v5/frontend/src/__tests__/time-series-chart.test.ts +lnt/server/ui/v5/frontend/src/__tests__/pages/dashboard.test.ts +lnt/server/ui/v5/frontend/src/__tests__/pages/machine-list.test.ts +lnt/server/ui/v5/frontend/src/__tests__/pages/machine-detail.test.ts +lnt/server/ui/v5/frontend/src/__tests__/pages/run-detail.test.ts +lnt/server/ui/v5/frontend/src/__tests__/pages/order-detail.test.ts +lnt/server/ui/v5/frontend/src/__tests__/pages/graph.test.ts +lnt/server/ui/v5/frontend/src/__tests__/pages/compare.test.ts +lnt/server/ui/v5/frontend/src/__tests__/pages/admin.test.ts +``` + +### Modified Files + +``` +lnt/server/ui/v5/frontend/vite.config.ts — Output v5.js/v5.css +lnt/server/ui/v5/frontend/src/main.ts — SPA bootstrap +lnt/server/ui/v5/frontend/src/api.ts — New API functions +lnt/server/ui/v5/frontend/src/types.ts — New interfaces +lnt/server/ui/v5/frontend/src/utils.ts — spaLink helper +lnt/server/ui/v5/frontend/src/comparison.ts — computeGeomean (GeomeanResult with A/B values) +lnt/server/ui/v5/frontend/src/table.ts — Geomean row, row toggling, summary message, resetTable() +lnt/server/ui/v5/frontend/src/chart.ts — Text filter, destroyChart(), preserveZoom, removed hideNoise +lnt/server/ui/v5/frontend/src/selection.ts — Removed Settings panel and Compare button, auto-select runs, tryAutoCompare(), swap sides button +lnt/server/ui/v5/frontend/src/state.ts — swapSides() function +lnt/server/ui/v5/frontend/src/combobox.ts — Order tags, machine filtering, per-side abort controllers +lnt/server/ui/v5/frontend/src/style.css — Nav bar + new page styles, row-hidden, table-message +lnt/server/ui/v5/views.py — Catch-all route +lnt/server/ui/templates/layout.html — v5 UI link in v4 nav, removed Compare link +lnt/server/ui/templates/layout.html — v5 UI link in v4 nav, nonav support +lnt/server/ui/v5/templates/v5_app.html — Standalone SPA shell (does not extend layout.html) +lnt/server/ui/v5/frontend/src/__tests__/api.test.ts — Tests for new API functions +lnt/server/ui/v5/frontend/src/__tests__/comparison.test.ts — Tests for geomean +``` + +### Deleted Files (after Phase 4) + +``` +lnt/server/ui/v5/templates/v5_compare.html — Replaced by v5_app.html +lnt/server/ui/v5/static/comparison/ — Replaced by static/v5/ +lnt/server/ui/v5/frontend/src/feedback.ts — Progress/error now handled per-page with simple DOM containers +``` diff --git a/lnt/server/ui/app.py b/lnt/server/ui/app.py index 1153bbe7b..0d85dd4a2 100644 --- a/lnt/server/ui/app.py +++ b/lnt/server/ui/app.py @@ -148,6 +148,10 @@ def create_with_instance(instance): # Load the application routes. app.register_blueprint(lnt.server.ui.views.frontend) + # Load the v5 frontend (comparison SPA, etc.). + from lnt.server.ui.v5 import v5_frontend + app.register_blueprint(v5_frontend) + # Load the flaskRESTful API. app.api = Api(app) load_api_resources(app.api) diff --git a/lnt/server/ui/templates/layout.html b/lnt/server/ui/templates/layout.html index 471a391e8..39101e2b4 100644 --- a/lnt/server/ui/templates/layout.html +++ b/lnt/server/ui/templates/layout.html @@ -3,23 +3,23 @@ - - + - - - - - - - @@ -31,7 +31,7 @@ - + @@ -71,6 +71,9 @@ {% if nosidebar is defined %} #page-content { margin-left:20px; width:100%} {% endif %} + {% if nonav is defined %} + #push, #header { height: 0px; } + {% endif %} /* Lastly, apply responsive CSS fixes as necessary */ @media (max-width: 767px) { #footer { @@ -88,7 +91,7 @@ - + {{old_config.name}}{% for short_name,_ in components %} : {{short_name}}{% endfor %} - {{ self.title() }} @@ -115,11 +118,12 @@ {# Top-Level Content (non-footer) #} <div id="wrap"> {# Page Header #} + {% if nonav is not defined %} <div id="header" class="navbar navbar-fixed-top"> <div class="navbar-inner"> {# LNT Instance Title #} <div id="lnt-instance"> - <a class="brand" href="{{url_for('.index')}}">{{old_config.name}}</a> + <a class="brand" href="{{url_for('lnt.index')}}">{{old_config.name}}</a> </div> {# Database Selector #} <ul class="nav"> @@ -128,7 +132,7 @@ <a href="#" class="dropdown-toggle" data-toggle="dropdown" id="dbselect" >Database <b class="caret"></b></a> <ul class="dropdown-menu"> {% for name in old_config.databases.keys()|sort %} - <li><a href="{{ url_for('.select_db', db=name, path=request.path) }}"> + <li><a href="{{ url_for('lnt.select_db', db=name, path=request.path) }}"> {% if name == g.db_name %} <b>{{ name }}</b> {% else %} @@ -146,7 +150,7 @@ <a href="#" class="dropdown-toggle" data-toggle="dropdown">Suite<b class="caret"></b></a> <ul class="dropdown-menu"> {% for name in request.get_db().testsuite %} - <li><a href="{{db_url_for('.v4_recent_activity', testsuite_name=name)}}">{{name}}</a></li> + <li><a href="{{db_url_for('lnt.v4_recent_activity', testsuite_name=name)}}">{{name}}</a></li> {% endfor %} </ul> </li> @@ -158,24 +162,25 @@ <li class="dropdown"> <a href="#" class="dropdown-toggle" data-toggle="dropdown">{{g.testsuite_name}}<b class="caret"></b></a> <ul class="dropdown-menu"> - <li><a href="{{ v4_url_for('.v4_recent_activity') }}">Recent Activity</a></li> - <li><a href="{{ v4_url_for('.v4_global_status') }}">Global Status</a></li> - <li><a href="{{ v4_url_for('.v4_daily_report_overview') }}">Daily Report</a></li> - <li><a href="{{ v4_url_for('.v4_latest_runs_report') }}">Latest Runs Report</a></li> - <li><a href="{{ v4_url_for('.v4_machines') }}">All Machines</a></li> + <li><a href="{{ v4_url_for('lnt.v4_recent_activity') }}">Recent Activity</a></li> + <li><a href="{{ v4_url_for('lnt.v4_global_status') }}">Global Status</a></li> + <li><a href="{{ v4_url_for('lnt.v4_daily_report_overview') }}">Daily Report</a></li> + <li><a href="{{ v4_url_for('lnt.v4_latest_runs_report') }}">Latest Runs Report</a></li> + <li><a href="{{ v4_url_for('lnt.v4_machines') }}">All Machines</a></li> + <li><a href="/v5/{{ g.testsuite_name }}/">v5 UI</a></li> <li class="divider"></li> <li class="disabled"><a href="#">Changes</a></li> - <li><a href="{{ v4_url_for('.v4_regression_list', state=0) }}">Detected</a></li> - <li><a href="{{ v4_url_for('.v4_regression_list', state=1) }}">Staged</a></li> - <li><a href="{{ v4_url_for('.v4_regression_list', state=10) }}">Active</a></li> - <li><a href="{{ v4_url_for('.v4_regression_list', state=20) }}">NTBF</a></li> - <li><a href="{{ v4_url_for('.v4_regression_list', state=21) }}">Ignored</a></li> - <li><a href="{{ v4_url_for('.v4_regression_list', state=23) }}">Verify</a></li> - <li><a href="{{ v4_url_for('.v4_regression_list', state=22) }}">Fixed</a></li> - <li><a href="{{ v4_url_for('.v4_regression_list', state=-1) }}">All</a></li> + <li><a href="{{ v4_url_for('lnt.v4_regression_list', state=0) }}">Detected</a></li> + <li><a href="{{ v4_url_for('lnt.v4_regression_list', state=1) }}">Staged</a></li> + <li><a href="{{ v4_url_for('lnt.v4_regression_list', state=10) }}">Active</a></li> + <li><a href="{{ v4_url_for('lnt.v4_regression_list', state=20) }}">NTBF</a></li> + <li><a href="{{ v4_url_for('lnt.v4_regression_list', state=21) }}">Ignored</a></li> + <li><a href="{{ v4_url_for('lnt.v4_regression_list', state=23) }}">Verify</a></li> + <li><a href="{{ v4_url_for('lnt.v4_regression_list', state=22) }}">Fixed</a></li> + <li><a href="{{ v4_url_for('lnt.v4_regression_list', state=-1) }}">All</a></li> <li class="divider"></li> <li class="disabled"><a href="#">Summary Report</a></li> - {#"{{ v4_url_for('.v4_summary_report') }}"#} + {#"{{ v4_url_for('lnt.v4_summary_report') }}"#} </ul> </li> </ul> @@ -188,7 +193,7 @@ <li class="nav-header">Select baseline:</li> {% for b in baselines %} {% set is_bold = b.id == baseline_id %} - <li><a href="{{ v4_url_for('.v4_set_baseline', id=b.id) }}"> + <li><a href="{{ v4_url_for('lnt.v4_set_baseline', id=b.id) }}"> {% if is_bold %} <b>{{ b.name }}</b> {% else %} @@ -205,9 +210,9 @@ <li class="dropdown"> <a href="#" class="dropdown-toggle" data-toggle="dropdown">System<b class="caret"></b></a> <ul class="dropdown-menu"> - <li><a href="{{ url_for('.rules') }}">Rules</a></li> - <li><a href="{{ url_for('.profile_admin') }}">Profiles</a></li> - <li><a href="{{ url_for('.static', filename='docs/index.html') }}">Documentation</a></li> + <li><a href="{{ url_for('lnt.rules') }}">Rules</a></li> + <li><a href="{{ url_for('lnt.profile_admin') }}">Profiles</a></li> + <li><a href="{{ url_for('lnt.static', filename='docs/index.html') }}">Documentation</a></li> </ul> </li> </ul> @@ -223,6 +228,7 @@ </div> </div> + {% endif %}{# nonav #} {# Include any database log, if present. #} {% if g.db_log is defined %} diff --git a/lnt/server/ui/v5/__init__.py b/lnt/server/ui/v5/__init__.py new file mode 100644 index 000000000..5ff35b1cc --- /dev/null +++ b/lnt/server/ui/v5/__init__.py @@ -0,0 +1,20 @@ +import flask +from flask import g + +from lnt.server.ui.decorators import _make_db_session + +v5_frontend = flask.Blueprint( + "lnt_v5", __name__, + template_folder="templates/", + static_folder="static/", + static_url_path="/v5/static", +) + + +def _setup_testsuite(testsuite_name, db_name=None): + """Shared setup for v5 UI routes: DB session + testsuite resolution.""" + g.testsuite_name = testsuite_name + _make_db_session(db_name) + + +from . import views # noqa: E402, F401 — register routes on the blueprint diff --git a/lnt/server/ui/v5/frontend/package-lock.json b/lnt/server/ui/v5/frontend/package-lock.json new file mode 100644 index 000000000..e8223060e --- /dev/null +++ b/lnt/server/ui/v5/frontend/package-lock.json @@ -0,0 +1,2080 @@ +{ + "name": "lnt-frontend", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "lnt-frontend", + "devDependencies": { + "jsdom": "^29.0.1", + "typescript": "^5.7.0", + "vite": "^6.0.0", + "vitest": "^3.0.0" + } + }, + "node_modules/@asamuzakjp/css-color": { + "version": "5.1.1", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@asamuzakjp/css-color/-/css-color-5.1.1.tgz", + "integrity": "sha512-iGWN8E45Ws0XWx3D44Q1t6vX2LqhCKcwfmwBYCDsFrYFS6m4q/Ks61L2veETaLv+ckDC6+dTETJoaAAb7VjLiw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@csstools/css-calc": "^3.1.1", + "@csstools/css-color-parser": "^4.0.2", + "@csstools/css-parser-algorithms": "^4.0.0", + "@csstools/css-tokenizer": "^4.0.0", + "lru-cache": "^11.2.7" + }, + "engines": { + "node": "^20.19.0 || ^22.12.0 || >=24.0.0" + } + }, + "node_modules/@asamuzakjp/dom-selector": { + "version": "7.0.4", + "resolved": "https://npm.apple.com/@asamuzakjp/dom-selector/-/dom-selector-7.0.4.tgz", + "integrity": "sha512-jXR6x4AcT3eIrS2fSNAwJpwirOkGcd+E7F7CP3zjdTqz9B/2huHOL8YJZBgekKwLML+u7qB/6P1LXQuMScsx0w==", + "dev": true, + "dependencies": { + "@asamuzakjp/nwsapi": "^2.3.9", + "bidi-js": "^1.0.3", + "css-tree": "^3.2.1", + "is-potential-custom-element-name": "^1.0.1", + "lru-cache": "^11.2.7" + }, + "engines": { + "node": "^20.19.0 || ^22.12.0 || >=24.0.0" + } + }, + "node_modules/@asamuzakjp/nwsapi": { + "version": "2.3.9", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@asamuzakjp/nwsapi/-/nwsapi-2.3.9.tgz", + "integrity": "sha512-n8GuYSrI9bF7FFZ/SjhwevlHc8xaVlb/7HmHelnc/PZXBD2ZR49NnN9sMMuDdEGPeeRQ5d0hqlSlEpgCX3Wl0Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/@bramus/specificity": { + "version": "2.4.2", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@bramus/specificity/-/specificity-2.4.2.tgz", + "integrity": "sha512-ctxtJ/eA+t+6q2++vj5j7FYX3nRu311q1wfYH3xjlLOsczhlhxAg2FWNUXhpGvAw3BWo1xBcvOV6/YLc2r5FJw==", + "dev": true, + "license": "MIT", + "dependencies": { + "css-tree": "^3.0.0" + }, + "bin": { + "specificity": "bin/cli.js" + } + }, + "node_modules/@csstools/color-helpers": { + "version": "6.0.2", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@csstools/color-helpers/-/color-helpers-6.0.2.tgz", + "integrity": "sha512-LMGQLS9EuADloEFkcTBR3BwV/CGHV7zyDxVRtVDTwdI2Ca4it0CCVTT9wCkxSgokjE5Ho41hEPgb8OEUwoXr6Q==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/csstools" + }, + { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + } + ], + "license": "MIT-0", + "engines": { + "node": ">=20.19.0" + } + }, + "node_modules/@csstools/css-calc": { + "version": "3.1.1", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@csstools/css-calc/-/css-calc-3.1.1.tgz", + "integrity": "sha512-HJ26Z/vmsZQqs/o3a6bgKslXGFAungXGbinULZO3eMsOyNJHeBBZfup5FiZInOghgoM4Hwnmw+OgbJCNg1wwUQ==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/csstools" + }, + { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + } + ], + "license": "MIT", + "engines": { + "node": ">=20.19.0" + }, + "peerDependencies": { + "@csstools/css-parser-algorithms": "^4.0.0", + "@csstools/css-tokenizer": "^4.0.0" + } + }, + "node_modules/@csstools/css-color-parser": { + "version": "4.0.2", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@csstools/css-color-parser/-/css-color-parser-4.0.2.tgz", + "integrity": "sha512-0GEfbBLmTFf0dJlpsNU7zwxRIH0/BGEMuXLTCvFYxuL1tNhqzTbtnFICyJLTNK4a+RechKP75e7w42ClXSnJQw==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/csstools" + }, + { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + } + ], + "license": "MIT", + "dependencies": { + "@csstools/color-helpers": "^6.0.2", + "@csstools/css-calc": "^3.1.1" + }, + "engines": { + "node": ">=20.19.0" + }, + "peerDependencies": { + "@csstools/css-parser-algorithms": "^4.0.0", + "@csstools/css-tokenizer": "^4.0.0" + } + }, + "node_modules/@csstools/css-parser-algorithms": { + "version": "4.0.0", + "resolved": "https://npm.apple.com/@csstools/css-parser-algorithms/-/css-parser-algorithms-4.0.0.tgz", + "integrity": "sha512-+B87qS7fIG3L5h3qwJ/IFbjoVoOe/bpOdh9hAjXbvx0o8ImEmUsGXN0inFOnk2ChCFgqkkGFQ+TpM5rbhkKe4w==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/csstools" + }, + { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + } + ], + "engines": { + "node": ">=20.19.0" + }, + "peerDependencies": { + "@csstools/css-tokenizer": "^4.0.0" + } + }, + "node_modules/@csstools/css-syntax-patches-for-csstree": { + "version": "1.1.2", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@csstools/css-syntax-patches-for-csstree/-/css-syntax-patches-for-csstree-1.1.2.tgz", + "integrity": "sha512-5GkLzz4prTIpoyeUiIu3iV6CSG3Plo7xRVOFPKI7FVEJ3mZ0A8SwK0XU3Gl7xAkiQ+mDyam+NNp875/C5y+jSA==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/csstools" + }, + { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + } + ], + "license": "MIT-0", + "peerDependencies": { + "css-tree": "^3.2.1" + }, + "peerDependenciesMeta": { + "css-tree": { + "optional": true + } + } + }, + "node_modules/@csstools/css-tokenizer": { + "version": "4.0.0", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@csstools/css-tokenizer/-/css-tokenizer-4.0.0.tgz", + "integrity": "sha512-QxULHAm7cNu72w97JUNCBFODFaXpbDg+dP8b/oWFAZ2MTRppA3U00Y2L1HqaS4J6yBqxwa/Y3nMBaxVKbB/NsA==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/csstools" + }, + { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + } + ], + "license": "MIT", + "engines": { + "node": ">=20.19.0" + } + }, + "node_modules/@esbuild/aix-ppc64": { + "version": "0.25.12", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@esbuild/aix-ppc64/-/aix-ppc64-0.25.12.tgz", + "integrity": "sha512-Hhmwd6CInZ3dwpuGTF8fJG6yoWmsToE+vYgD4nytZVxcu1ulHpUQRAB1UJ8+N1Am3Mz4+xOByoQoSZf4D+CpkA==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "aix" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-arm": { + "version": "0.25.12", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@esbuild/android-arm/-/android-arm-0.25.12.tgz", + "integrity": "sha512-VJ+sKvNA/GE7Ccacc9Cha7bpS8nyzVv0jdVgwNDaR4gDMC/2TTRc33Ip8qrNYUcpkOHUT5OZ0bUcNNVZQ9RLlg==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-arm64": { + "version": "0.25.12", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@esbuild/android-arm64/-/android-arm64-0.25.12.tgz", + "integrity": "sha512-6AAmLG7zwD1Z159jCKPvAxZd4y/VTO0VkprYy+3N2FtJ8+BQWFXU+OxARIwA46c5tdD9SsKGZ/1ocqBS/gAKHg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-x64": { + "version": "0.25.12", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@esbuild/android-x64/-/android-x64-0.25.12.tgz", + "integrity": "sha512-5jbb+2hhDHx5phYR2By8GTWEzn6I9UqR11Kwf22iKbNpYrsmRB18aX/9ivc5cabcUiAT/wM+YIZ6SG9QO6a8kg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/darwin-arm64": { + "version": "0.25.12", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@esbuild/darwin-arm64/-/darwin-arm64-0.25.12.tgz", + "integrity": "sha512-N3zl+lxHCifgIlcMUP5016ESkeQjLj/959RxxNYIthIg+CQHInujFuXeWbWMgnTo4cp5XVHqFPmpyu9J65C1Yg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/darwin-x64": { + "version": "0.25.12", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@esbuild/darwin-x64/-/darwin-x64-0.25.12.tgz", + "integrity": "sha512-HQ9ka4Kx21qHXwtlTUVbKJOAnmG1ipXhdWTmNXiPzPfWKpXqASVcWdnf2bnL73wgjNrFXAa3yYvBSd9pzfEIpA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/freebsd-arm64": { + "version": "0.25.12", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.12.tgz", + "integrity": "sha512-gA0Bx759+7Jve03K1S0vkOu5Lg/85dou3EseOGUes8flVOGxbhDDh/iZaoek11Y8mtyKPGF3vP8XhnkDEAmzeg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/freebsd-x64": { + "version": "0.25.12", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@esbuild/freebsd-x64/-/freebsd-x64-0.25.12.tgz", + "integrity": "sha512-TGbO26Yw2xsHzxtbVFGEXBFH0FRAP7gtcPE7P5yP7wGy7cXK2oO7RyOhL5NLiqTlBh47XhmIUXuGciXEqYFfBQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-arm": { + "version": "0.25.12", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@esbuild/linux-arm/-/linux-arm-0.25.12.tgz", + "integrity": "sha512-lPDGyC1JPDou8kGcywY0YILzWlhhnRjdof3UlcoqYmS9El818LLfJJc3PXXgZHrHCAKs/Z2SeZtDJr5MrkxtOw==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-arm64": { + "version": "0.25.12", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@esbuild/linux-arm64/-/linux-arm64-0.25.12.tgz", + "integrity": "sha512-8bwX7a8FghIgrupcxb4aUmYDLp8pX06rGh5HqDT7bB+8Rdells6mHvrFHHW2JAOPZUbnjUpKTLg6ECyzvas2AQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-ia32": { + "version": "0.25.12", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@esbuild/linux-ia32/-/linux-ia32-0.25.12.tgz", + "integrity": "sha512-0y9KrdVnbMM2/vG8KfU0byhUN+EFCny9+8g202gYqSSVMonbsCfLjUO+rCci7pM0WBEtz+oK/PIwHkzxkyharA==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-loong64": { + "version": "0.25.12", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@esbuild/linux-loong64/-/linux-loong64-0.25.12.tgz", + "integrity": "sha512-h///Lr5a9rib/v1GGqXVGzjL4TMvVTv+s1DPoxQdz7l/AYv6LDSxdIwzxkrPW438oUXiDtwM10o9PmwS/6Z0Ng==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-mips64el": { + "version": "0.25.12", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@esbuild/linux-mips64el/-/linux-mips64el-0.25.12.tgz", + "integrity": "sha512-iyRrM1Pzy9GFMDLsXn1iHUm18nhKnNMWscjmp4+hpafcZjrr2WbT//d20xaGljXDBYHqRcl8HnxbX6uaA/eGVw==", + "cpu": [ + "mips64el" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-ppc64": { + "version": "0.25.12", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@esbuild/linux-ppc64/-/linux-ppc64-0.25.12.tgz", + "integrity": "sha512-9meM/lRXxMi5PSUqEXRCtVjEZBGwB7P/D4yT8UG/mwIdze2aV4Vo6U5gD3+RsoHXKkHCfSxZKzmDssVlRj1QQA==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-riscv64": { + "version": "0.25.12", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@esbuild/linux-riscv64/-/linux-riscv64-0.25.12.tgz", + "integrity": "sha512-Zr7KR4hgKUpWAwb1f3o5ygT04MzqVrGEGXGLnj15YQDJErYu/BGg+wmFlIDOdJp0PmB0lLvxFIOXZgFRrdjR0w==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-s390x": { + "version": "0.25.12", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@esbuild/linux-s390x/-/linux-s390x-0.25.12.tgz", + "integrity": "sha512-MsKncOcgTNvdtiISc/jZs/Zf8d0cl/t3gYWX8J9ubBnVOwlk65UIEEvgBORTiljloIWnBzLs4qhzPkJcitIzIg==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-x64": { + "version": "0.25.12", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@esbuild/linux-x64/-/linux-x64-0.25.12.tgz", + "integrity": "sha512-uqZMTLr/zR/ed4jIGnwSLkaHmPjOjJvnm6TVVitAa08SLS9Z0VM8wIRx7gWbJB5/J54YuIMInDquWyYvQLZkgw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/netbsd-arm64": { + "version": "0.25.12", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.12.tgz", + "integrity": "sha512-xXwcTq4GhRM7J9A8Gv5boanHhRa/Q9KLVmcyXHCTaM4wKfIpWkdXiMog/KsnxzJ0A1+nD+zoecuzqPmCRyBGjg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/netbsd-x64": { + "version": "0.25.12", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@esbuild/netbsd-x64/-/netbsd-x64-0.25.12.tgz", + "integrity": "sha512-Ld5pTlzPy3YwGec4OuHh1aCVCRvOXdH8DgRjfDy/oumVovmuSzWfnSJg+VtakB9Cm0gxNO9BzWkj6mtO1FMXkQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openbsd-arm64": { + "version": "0.25.12", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.12.tgz", + "integrity": "sha512-fF96T6KsBo/pkQI950FARU9apGNTSlZGsv1jZBAlcLL1MLjLNIWPBkj5NlSz8aAzYKg+eNqknrUJ24QBybeR5A==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openbsd-x64": { + "version": "0.25.12", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@esbuild/openbsd-x64/-/openbsd-x64-0.25.12.tgz", + "integrity": "sha512-MZyXUkZHjQxUvzK7rN8DJ3SRmrVrke8ZyRusHlP+kuwqTcfWLyqMOE3sScPPyeIXN/mDJIfGXvcMqCgYKekoQw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openharmony-arm64": { + "version": "0.25.12", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@esbuild/openharmony-arm64/-/openharmony-arm64-0.25.12.tgz", + "integrity": "sha512-rm0YWsqUSRrjncSXGA7Zv78Nbnw4XL6/dzr20cyrQf7ZmRcsovpcRBdhD43Nuk3y7XIoW2OxMVvwuRvk9XdASg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/sunos-x64": { + "version": "0.25.12", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@esbuild/sunos-x64/-/sunos-x64-0.25.12.tgz", + "integrity": "sha512-3wGSCDyuTHQUzt0nV7bocDy72r2lI33QL3gkDNGkod22EsYl04sMf0qLb8luNKTOmgF/eDEDP5BFNwoBKH441w==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "sunos" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-arm64": { + "version": "0.25.12", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@esbuild/win32-arm64/-/win32-arm64-0.25.12.tgz", + "integrity": "sha512-rMmLrur64A7+DKlnSuwqUdRKyd3UE7oPJZmnljqEptesKM8wx9J8gx5u0+9Pq0fQQW8vqeKebwNXdfOyP+8Bsg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-ia32": { + "version": "0.25.12", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@esbuild/win32-ia32/-/win32-ia32-0.25.12.tgz", + "integrity": "sha512-HkqnmmBoCbCwxUKKNPBixiWDGCpQGVsrQfJoVGYLPT41XWF8lHuE5N6WhVia2n4o5QK5M4tYr21827fNhi4byQ==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-x64": { + "version": "0.25.12", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@esbuild/win32-x64/-/win32-x64-0.25.12.tgz", + "integrity": "sha512-alJC0uCZpTFrSL0CCDjcgleBXPnCrEAhTBILpeAp7M/OFgoqtAetfBzX0xM00MUsVVPpVjlPuMbREqnZCXaTnA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@exodus/bytes": { + "version": "1.15.0", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@exodus/bytes/-/bytes-1.15.0.tgz", + "integrity": "sha512-UY0nlA+feH81UGSHv92sLEPLCeZFjXOuHhrIo0HQydScuQc8s0A7kL/UdgwgDq8g8ilksmuoF35YVTNphV2aBQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^20.19.0 || ^22.12.0 || >=24.0.0" + }, + "peerDependencies": { + "@noble/hashes": "^1.8.0 || ^2.0.0" + }, + "peerDependenciesMeta": { + "@noble/hashes": { + "optional": true + } + } + }, + "node_modules/@jridgewell/sourcemap-codec": { + "version": "1.5.5", + "resolved": "https://npm.apple.com/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz", + "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==", + "dev": true + }, + "node_modules/@rollup/rollup-android-arm-eabi": { + "version": "4.60.0", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.60.0.tgz", + "integrity": "sha512-WOhNW9K8bR3kf4zLxbfg6Pxu2ybOUbB2AjMDHSQx86LIF4rH4Ft7vmMwNt0loO0eonglSNy4cpD3MKXXKQu0/A==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-android-arm64": { + "version": "4.60.0", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.60.0.tgz", + "integrity": "sha512-u6JHLll5QKRvjciE78bQXDmqRqNs5M/3GVqZeMwvmjaNODJih/WIrJlFVEihvV0MiYFmd+ZyPr9wxOVbPAG2Iw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-darwin-arm64": { + "version": "4.60.0", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.60.0.tgz", + "integrity": "sha512-qEF7CsKKzSRc20Ciu2Zw1wRrBz4g56F7r/vRwY430UPp/nt1x21Q/fpJ9N5l47WWvJlkNCPJz3QRVw008fi7yA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-darwin-x64": { + "version": "4.60.0", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.60.0.tgz", + "integrity": "sha512-WADYozJ4QCnXCH4wPB+3FuGmDPoFseVCUrANmA5LWwGmC6FL14BWC7pcq+FstOZv3baGX65tZ378uT6WG8ynTw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-freebsd-arm64": { + "version": "4.60.0", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.60.0.tgz", + "integrity": "sha512-6b8wGHJlDrGeSE3aH5mGNHBjA0TTkxdoNHik5EkvPHCt351XnigA4pS7Wsj/Eo9Y8RBU6f35cjN9SYmCFBtzxw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ] + }, + "node_modules/@rollup/rollup-freebsd-x64": { + "version": "4.60.0", + "resolved": "https://npm.apple.com/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.60.0.tgz", + "integrity": "sha512-h25Ga0t4jaylMB8M/JKAyrvvfxGRjnPQIR8lnCayyzEjEOx2EJIlIiMbhpWxDRKGKF8jbNH01NnN663dH638mA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ] + }, + "node_modules/@rollup/rollup-linux-arm-gnueabihf": { + "version": "4.60.0", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.60.0.tgz", + "integrity": "sha512-RzeBwv0B3qtVBWtcuABtSuCzToo2IEAIQrcyB/b2zMvBWVbjo8bZDjACUpnaafaxhTw2W+imQbP2BD1usasK4g==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm-musleabihf": { + "version": "4.60.0", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.60.0.tgz", + "integrity": "sha512-Sf7zusNI2CIU1HLzuu9Tc5YGAHEZs5Lu7N1ssJG4Tkw6e0MEsN7NdjUDDfGNHy2IU+ENyWT+L2obgWiguWibWQ==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-gnu": { + "version": "4.60.0", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.60.0.tgz", + "integrity": "sha512-DX2x7CMcrJzsE91q7/O02IJQ5/aLkVtYFryqCjduJhUfGKG6yJV8hxaw8pZa93lLEpPTP/ohdN4wFz7yp/ry9A==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-musl": { + "version": "4.60.0", + "resolved": "https://npm.apple.com/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.60.0.tgz", + "integrity": "sha512-09EL+yFVbJZlhcQfShpswwRZ0Rg+z/CsSELFCnPt3iK+iqwGsI4zht3secj5vLEs957QvFFXnzAT0FFPIxSrkQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-loong64-gnu": { + "version": "4.60.0", + "resolved": "https://npm.apple.com/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.60.0.tgz", + "integrity": "sha512-i9IcCMPr3EXm8EQg5jnja0Zyc1iFxJjZWlb4wr7U2Wx/GrddOuEafxRdMPRYVaXjgbhvqalp6np07hN1w9kAKw==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-loong64-musl": { + "version": "4.60.0", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.60.0.tgz", + "integrity": "sha512-DGzdJK9kyJ+B78MCkWeGnpXJ91tK/iKA6HwHxF4TAlPIY7GXEvMe8hBFRgdrR9Ly4qebR/7gfUs9y2IoaVEyog==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-ppc64-gnu": { + "version": "4.60.0", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.60.0.tgz", + "integrity": "sha512-RwpnLsqC8qbS8z1H1AxBA1H6qknR4YpPR9w2XX0vo2Sz10miu57PkNcnHVaZkbqyw/kUWfKMI73jhmfi9BRMUQ==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-ppc64-musl": { + "version": "4.60.0", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.60.0.tgz", + "integrity": "sha512-Z8pPf54Ly3aqtdWC3G4rFigZgNvd+qJlOE52fmko3KST9SoGfAdSRCwyoyG05q1HrrAblLbk1/PSIV+80/pxLg==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-gnu": { + "version": "4.60.0", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.60.0.tgz", + "integrity": "sha512-3a3qQustp3COCGvnP4SvrMHnPQ9d1vzCakQVRTliaz8cIp/wULGjiGpbcqrkv0WrHTEp8bQD/B3HBjzujVWLOA==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-musl": { + "version": "4.60.0", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.60.0.tgz", + "integrity": "sha512-pjZDsVH/1VsghMJ2/kAaxt6dL0psT6ZexQVrijczOf+PeP2BUqTHYejk3l6TlPRydggINOeNRhvpLa0AYpCWSQ==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-s390x-gnu": { + "version": "4.60.0", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.60.0.tgz", + "integrity": "sha512-3ObQs0BhvPgiUVZrN7gqCSvmFuMWvWvsjG5ayJ3Lraqv+2KhOsp+pUbigqbeWqueGIsnn+09HBw27rJ+gYK4VQ==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-gnu": { + "version": "4.60.0", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.60.0.tgz", + "integrity": "sha512-EtylprDtQPdS5rXvAayrNDYoJhIz1/vzN2fEubo3yLE7tfAw+948dO0g4M0vkTVFhKojnF+n6C8bDNe+gDRdTg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-musl": { + "version": "4.60.0", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.60.0.tgz", + "integrity": "sha512-k09oiRCi/bHU9UVFqD17r3eJR9bn03TyKraCrlz5ULFJGdJGi7VOmm9jl44vOJvRJ6P7WuBi/s2A97LxxHGIdw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-openbsd-x64": { + "version": "4.60.0", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.60.0.tgz", + "integrity": "sha512-1o/0/pIhozoSaDJoDcec+IVLbnRtQmHwPV730+AOD29lHEEo4F5BEUB24H0OBdhbBBDwIOSuf7vgg0Ywxdfiiw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ] + }, + "node_modules/@rollup/rollup-openharmony-arm64": { + "version": "4.60.0", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.60.0.tgz", + "integrity": "sha512-pESDkos/PDzYwtyzB5p/UoNU/8fJo68vcXM9ZW2V0kjYayj1KaaUfi1NmTUTUpMn4UhU4gTuK8gIaFO4UGuMbA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ] + }, + "node_modules/@rollup/rollup-win32-arm64-msvc": { + "version": "4.60.0", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.60.0.tgz", + "integrity": "sha512-hj1wFStD7B1YBeYmvY+lWXZ7ey73YGPcViMShYikqKT1GtstIKQAtfUI6yrzPjAy/O7pO0VLXGmUVWXQMaYgTQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-ia32-msvc": { + "version": "4.60.0", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.60.0.tgz", + "integrity": "sha512-SyaIPFoxmUPlNDq5EHkTbiKzmSEmq/gOYFI/3HHJ8iS/v1mbugVa7dXUzcJGQfoytp9DJFLhHH4U3/eTy2Bq4w==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-gnu": { + "version": "4.60.0", + "resolved": "https://npm.apple.com/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.60.0.tgz", + "integrity": "sha512-RdcryEfzZr+lAr5kRm2ucN9aVlCCa2QNq4hXelZxb8GG0NJSazq44Z3PCCc8wISRuCVnGs0lQJVX5Vp6fKA+IA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-msvc": { + "version": "4.60.0", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.60.0.tgz", + "integrity": "sha512-PrsWNQ8BuE00O3Xsx3ALh2Df8fAj9+cvvX9AIA6o4KpATR98c9mud4XtDWVvsEuyia5U4tVSTKygawyJkjm60w==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@types/chai": { + "version": "5.2.3", + "resolved": "https://npm.apple.com/@types/chai/-/chai-5.2.3.tgz", + "integrity": "sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==", + "dev": true, + "dependencies": { + "@types/deep-eql": "*", + "assertion-error": "^2.0.1" + } + }, + "node_modules/@types/deep-eql": { + "version": "4.0.2", + "resolved": "https://npm.apple.com/@types/deep-eql/-/deep-eql-4.0.2.tgz", + "integrity": "sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==", + "dev": true + }, + "node_modules/@types/estree": { + "version": "1.0.8", + "resolved": "https://npm.apple.com/@types/estree/-/estree-1.0.8.tgz", + "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==", + "dev": true, + "license": "MIT" + }, + "node_modules/@vitest/expect": { + "version": "3.2.4", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@vitest/expect/-/expect-3.2.4.tgz", + "integrity": "sha512-Io0yyORnB6sikFlt8QW5K7slY4OjqNX9jmJQ02QDda8lyM6B5oNgVWoSoKPac8/kgnCUzuHQKrSLtu/uOqqrig==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/chai": "^5.2.2", + "@vitest/spy": "3.2.4", + "@vitest/utils": "3.2.4", + "chai": "^5.2.0", + "tinyrainbow": "^2.0.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/mocker": { + "version": "3.2.4", + "resolved": "https://npm.apple.com/@vitest/mocker/-/mocker-3.2.4.tgz", + "integrity": "sha512-46ryTE9RZO/rfDd7pEqFl7etuyzekzEhUbTW3BvmeO/BcCMEgq59BKhek3dXDWgAj4oMK6OZi+vRr1wPW6qjEQ==", + "dev": true, + "dependencies": { + "@vitest/spy": "3.2.4", + "estree-walker": "^3.0.3", + "magic-string": "^0.30.17" + }, + "funding": { + "url": "https://opencollective.com/vitest" + }, + "peerDependencies": { + "msw": "^2.4.9", + "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0" + }, + "peerDependenciesMeta": { + "msw": { + "optional": true + }, + "vite": { + "optional": true + } + } + }, + "node_modules/@vitest/pretty-format": { + "version": "3.2.4", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@vitest/pretty-format/-/pretty-format-3.2.4.tgz", + "integrity": "sha512-IVNZik8IVRJRTr9fxlitMKeJeXFFFN0JaB9PHPGQ8NKQbGpfjlTx9zO4RefN8gp7eqjNy8nyK3NZmBzOPeIxtA==", + "dev": true, + "license": "MIT", + "dependencies": { + "tinyrainbow": "^2.0.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/runner": { + "version": "3.2.4", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@vitest/runner/-/runner-3.2.4.tgz", + "integrity": "sha512-oukfKT9Mk41LreEW09vt45f8wx7DordoWUZMYdY/cyAk7w5TWkTRCNZYF7sX7n2wB7jyGAl74OxgwhPgKaqDMQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vitest/utils": "3.2.4", + "pathe": "^2.0.3", + "strip-literal": "^3.0.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/snapshot": { + "version": "3.2.4", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@vitest/snapshot/-/snapshot-3.2.4.tgz", + "integrity": "sha512-dEYtS7qQP2CjU27QBC5oUOxLE/v5eLkGqPE0ZKEIDGMs4vKWe7IjgLOeauHsR0D5YuuycGRO5oSRXnwnmA78fQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vitest/pretty-format": "3.2.4", + "magic-string": "^0.30.17", + "pathe": "^2.0.3" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/spy": { + "version": "3.2.4", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@vitest/spy/-/spy-3.2.4.tgz", + "integrity": "sha512-vAfasCOe6AIK70iP5UD11Ac4siNUNJ9i/9PZ3NKx07sG6sUxeag1LWdNrMWeKKYBLlzuK+Gn65Yd5nyL6ds+nw==", + "dev": true, + "license": "MIT", + "dependencies": { + "tinyspy": "^4.0.3" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/utils": { + "version": "3.2.4", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/@vitest/utils/-/utils-3.2.4.tgz", + "integrity": "sha512-fB2V0JFrQSMsCo9HiSq3Ezpdv4iYaXRG1Sx8edX3MwxfyNn83mKiGzOcH+Fkxt4MHxr3y42fQi1oeAInqgX2QA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vitest/pretty-format": "3.2.4", + "loupe": "^3.1.4", + "tinyrainbow": "^2.0.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/assertion-error": { + "version": "2.0.1", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/assertion-error/-/assertion-error-2.0.1.tgz", + "integrity": "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + } + }, + "node_modules/bidi-js": { + "version": "1.0.3", + "resolved": "https://npm.apple.com/bidi-js/-/bidi-js-1.0.3.tgz", + "integrity": "sha512-RKshQI1R3YQ+n9YJz2QQ147P66ELpa1FQEg20Dk8oW9t2KgLbpDLLp9aGZ7y8WHSshDknG0bknqGw5/tyCs5tw==", + "dev": true, + "dependencies": { + "require-from-string": "^2.0.2" + } + }, + "node_modules/cac": { + "version": "6.7.14", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/cac/-/cac-6.7.14.tgz", + "integrity": "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/chai": { + "version": "5.3.3", + "resolved": "https://npm.apple.com/chai/-/chai-5.3.3.tgz", + "integrity": "sha512-4zNhdJD/iOjSH0A05ea+Ke6MU5mmpQcbQsSOkgdaUMJ9zTlDTD/GYlwohmIE2u0gaxHYiVHEn1Fw9mZ/ktJWgw==", + "dev": true, + "dependencies": { + "assertion-error": "^2.0.1", + "check-error": "^2.1.1", + "deep-eql": "^5.0.1", + "loupe": "^3.1.0", + "pathval": "^2.0.0" + }, + "engines": { + "node": ">=18" + } + }, + "node_modules/check-error": { + "version": "2.1.3", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/check-error/-/check-error-2.1.3.tgz", + "integrity": "sha512-PAJdDJusoxnwm1VwW07VWwUN1sl7smmC3OKggvndJFadxxDRyFJBX/ggnu/KE4kQAB7a3Dp8f/YXC1FlUprWmA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 16" + } + }, + "node_modules/css-tree": { + "version": "3.2.1", + "resolved": "https://npm.apple.com/css-tree/-/css-tree-3.2.1.tgz", + "integrity": "sha512-X7sjQzceUhu1u7Y/ylrRZFU2FS6LRiFVp6rKLPg23y3x3c3DOKAwuXGDp+PAGjh6CSnCjYeAul8pcT8bAl+lSA==", + "dev": true, + "dependencies": { + "mdn-data": "2.27.1", + "source-map-js": "^1.2.1" + }, + "engines": { + "node": "^10 || ^12.20.0 || ^14.13.0 || >=15.0.0" + } + }, + "node_modules/data-urls": { + "version": "7.0.0", + "resolved": "https://npm.apple.com/data-urls/-/data-urls-7.0.0.tgz", + "integrity": "sha512-23XHcCF+coGYevirZceTVD7NdJOqVn+49IHyxgszm+JIiHLoB2TkmPtsYkNWT1pvRSGkc35L6NHs0yHkN2SumA==", + "dev": true, + "dependencies": { + "whatwg-mimetype": "^5.0.0", + "whatwg-url": "^16.0.0" + }, + "engines": { + "node": "^20.19.0 || ^22.12.0 || >=24.0.0" + } + }, + "node_modules/debug": { + "version": "4.4.3", + "resolved": "https://npm.apple.com/debug/-/debug-4.4.3.tgz", + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", + "dev": true, + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/decimal.js": { + "version": "10.6.0", + "resolved": "https://npm.apple.com/decimal.js/-/decimal.js-10.6.0.tgz", + "integrity": "sha512-YpgQiITW3JXGntzdUmyUR1V812Hn8T1YVXhCu+wO3OpS4eU9l4YdD3qjyiKdV6mvV29zapkMeD390UVEf2lkUg==", + "dev": true + }, + "node_modules/deep-eql": { + "version": "5.0.2", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/deep-eql/-/deep-eql-5.0.2.tgz", + "integrity": "sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/entities": { + "version": "6.0.1", + "resolved": "https://npm.apple.com/entities/-/entities-6.0.1.tgz", + "integrity": "sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g==", + "dev": true, + "engines": { + "node": ">=0.12" + }, + "funding": { + "url": "https://github.com/fb55/entities?sponsor=1" + } + }, + "node_modules/es-module-lexer": { + "version": "1.7.0", + "resolved": "https://npm.apple.com/es-module-lexer/-/es-module-lexer-1.7.0.tgz", + "integrity": "sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==", + "dev": true + }, + "node_modules/esbuild": { + "version": "0.25.12", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/esbuild/-/esbuild-0.25.12.tgz", + "integrity": "sha512-bbPBYYrtZbkt6Os6FiTLCTFxvq4tt3JKall1vRwshA3fdVztsLAatFaZobhkBC8/BrPetoa0oksYoKXoG4ryJg==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "bin": { + "esbuild": "bin/esbuild" + }, + "engines": { + "node": ">=18" + }, + "optionalDependencies": { + "@esbuild/aix-ppc64": "0.25.12", + "@esbuild/android-arm": "0.25.12", + "@esbuild/android-arm64": "0.25.12", + "@esbuild/android-x64": "0.25.12", + "@esbuild/darwin-arm64": "0.25.12", + "@esbuild/darwin-x64": "0.25.12", + "@esbuild/freebsd-arm64": "0.25.12", + "@esbuild/freebsd-x64": "0.25.12", + "@esbuild/linux-arm": "0.25.12", + "@esbuild/linux-arm64": "0.25.12", + "@esbuild/linux-ia32": "0.25.12", + "@esbuild/linux-loong64": "0.25.12", + "@esbuild/linux-mips64el": "0.25.12", + "@esbuild/linux-ppc64": "0.25.12", + "@esbuild/linux-riscv64": "0.25.12", + "@esbuild/linux-s390x": "0.25.12", + "@esbuild/linux-x64": "0.25.12", + "@esbuild/netbsd-arm64": "0.25.12", + "@esbuild/netbsd-x64": "0.25.12", + "@esbuild/openbsd-arm64": "0.25.12", + "@esbuild/openbsd-x64": "0.25.12", + "@esbuild/openharmony-arm64": "0.25.12", + "@esbuild/sunos-x64": "0.25.12", + "@esbuild/win32-arm64": "0.25.12", + "@esbuild/win32-ia32": "0.25.12", + "@esbuild/win32-x64": "0.25.12" + } + }, + "node_modules/estree-walker": { + "version": "3.0.3", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/estree-walker/-/estree-walker-3.0.3.tgz", + "integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/estree": "^1.0.0" + } + }, + "node_modules/expect-type": { + "version": "1.3.0", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/expect-type/-/expect-type-1.3.0.tgz", + "integrity": "sha512-knvyeauYhqjOYvQ66MznSMs83wmHrCycNEN6Ao+2AeYEfxUIkuiVxdEa1qlGEPK+We3n0THiDciYSsCcgW/DoA==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=12.0.0" + } + }, + "node_modules/fdir": { + "version": "6.5.0", + "resolved": "https://npm.apple.com/fdir/-/fdir-6.5.0.tgz", + "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==", + "dev": true, + "engines": { + "node": ">=12.0.0" + }, + "peerDependencies": { + "picomatch": "^3 || ^4" + }, + "peerDependenciesMeta": { + "picomatch": { + "optional": true + } + } + }, + "node_modules/fsevents": { + "version": "2.3.3", + "resolved": "https://npm.apple.com/fsevents/-/fsevents-2.3.3.tgz", + "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/html-encoding-sniffer": { + "version": "6.0.0", + "resolved": "https://npm.apple.com/html-encoding-sniffer/-/html-encoding-sniffer-6.0.0.tgz", + "integrity": "sha512-CV9TW3Y3f8/wT0BRFc1/KAVQ3TUHiXmaAb6VW9vtiMFf7SLoMd1PdAc4W3KFOFETBJUb90KatHqlsZMWV+R9Gg==", + "dev": true, + "dependencies": { + "@exodus/bytes": "^1.6.0" + }, + "engines": { + "node": "^20.19.0 || ^22.12.0 || >=24.0.0" + } + }, + "node_modules/is-potential-custom-element-name": { + "version": "1.0.1", + "resolved": "https://npm.apple.com/is-potential-custom-element-name/-/is-potential-custom-element-name-1.0.1.tgz", + "integrity": "sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ==", + "dev": true + }, + "node_modules/js-tokens": { + "version": "9.0.1", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/js-tokens/-/js-tokens-9.0.1.tgz", + "integrity": "sha512-mxa9E9ITFOt0ban3j6L5MpjwegGz6lBQmM1IJkWeBZGcMxto50+eWdjC/52xDbS2vy0k7vIMK0Fe2wfL9OQSpQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/jsdom": { + "version": "29.0.1", + "resolved": "https://npm.apple.com/jsdom/-/jsdom-29.0.1.tgz", + "integrity": "sha512-z6JOK5gRO7aMybVq/y/MlIpKh8JIi68FBKMUtKkK2KH/wMSRlCxQ682d08LB9fYXplyY/UXG8P4XXTScmdjApg==", + "dev": true, + "dependencies": { + "@asamuzakjp/css-color": "^5.0.1", + "@asamuzakjp/dom-selector": "^7.0.3", + "@bramus/specificity": "^2.4.2", + "@csstools/css-syntax-patches-for-csstree": "^1.1.1", + "@exodus/bytes": "^1.15.0", + "css-tree": "^3.2.1", + "data-urls": "^7.0.0", + "decimal.js": "^10.6.0", + "html-encoding-sniffer": "^6.0.0", + "is-potential-custom-element-name": "^1.0.1", + "lru-cache": "^11.2.7", + "parse5": "^8.0.0", + "saxes": "^6.0.0", + "symbol-tree": "^3.2.4", + "tough-cookie": "^6.0.1", + "undici": "^7.24.5", + "w3c-xmlserializer": "^5.0.0", + "webidl-conversions": "^8.0.1", + "whatwg-mimetype": "^5.0.0", + "whatwg-url": "^16.0.1", + "xml-name-validator": "^5.0.0" + }, + "engines": { + "node": "^20.19.0 || ^22.13.0 || >=24.0.0" + }, + "peerDependencies": { + "canvas": "^3.0.0" + }, + "peerDependenciesMeta": { + "canvas": { + "optional": true + } + } + }, + "node_modules/loupe": { + "version": "3.2.1", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/loupe/-/loupe-3.2.1.tgz", + "integrity": "sha512-CdzqowRJCeLU72bHvWqwRBBlLcMEtIvGrlvef74kMnV2AolS9Y8xUv1I0U/MNAWMhBlKIoyuEgoJ0t/bbwHbLQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/lru-cache": { + "version": "11.2.7", + "resolved": "https://npm.apple.com/lru-cache/-/lru-cache-11.2.7.tgz", + "integrity": "sha512-aY/R+aEsRelme17KGQa/1ZSIpLpNYYrhcrepKTZgE+W3WM16YMCaPwOHLHsmopZHELU0Ojin1lPVxKR0MihncA==", + "dev": true, + "engines": { + "node": "20 || >=22" + } + }, + "node_modules/magic-string": { + "version": "0.30.21", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/magic-string/-/magic-string-0.30.21.tgz", + "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/sourcemap-codec": "^1.5.5" + } + }, + "node_modules/mdn-data": { + "version": "2.27.1", + "resolved": "https://npm.apple.com/mdn-data/-/mdn-data-2.27.1.tgz", + "integrity": "sha512-9Yubnt3e8A0OKwxYSXyhLymGW4sCufcLG6VdiDdUGVkPhpqLxlvP5vl1983gQjJl3tqbrM731mjaZaP68AgosQ==", + "dev": true + }, + "node_modules/ms": { + "version": "2.1.3", + "resolved": "https://npm.apple.com/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "dev": true + }, + "node_modules/nanoid": { + "version": "3.3.11", + "resolved": "https://npm.apple.com/nanoid/-/nanoid-3.3.11.tgz", + "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "bin": { + "nanoid": "bin/nanoid.cjs" + }, + "engines": { + "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" + } + }, + "node_modules/parse5": { + "version": "8.0.0", + "resolved": "https://npm.apple.com/parse5/-/parse5-8.0.0.tgz", + "integrity": "sha512-9m4m5GSgXjL4AjumKzq1Fgfp3Z8rsvjRNbnkVwfu2ImRqE5D0LnY2QfDen18FSY9C573YU5XxSapdHZTZ2WolA==", + "dev": true, + "dependencies": { + "entities": "^6.0.0" + }, + "funding": { + "url": "https://github.com/inikulin/parse5?sponsor=1" + } + }, + "node_modules/pathe": { + "version": "2.0.3", + "resolved": "https://npm.apple.com/pathe/-/pathe-2.0.3.tgz", + "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==", + "dev": true + }, + "node_modules/pathval": { + "version": "2.0.1", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/pathval/-/pathval-2.0.1.tgz", + "integrity": "sha512-//nshmD55c46FuFw26xV/xFAaB5HF9Xdap7HJBBnrKdAd6/GxDBaNA1870O79+9ueg61cZLSVc+OaFlfmObYVQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 14.16" + } + }, + "node_modules/picocolors": { + "version": "1.1.1", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/picocolors/-/picocolors-1.1.1.tgz", + "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==", + "dev": true, + "license": "ISC" + }, + "node_modules/picomatch": { + "version": "4.0.4", + "resolved": "https://npm.apple.com/picomatch/-/picomatch-4.0.4.tgz", + "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==", + "dev": true, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/postcss": { + "version": "8.5.8", + "resolved": "https://npm.apple.com/postcss/-/postcss-8.5.8.tgz", + "integrity": "sha512-OW/rX8O/jXnm82Ey1k44pObPtdblfiuWnrd8X7GJ7emImCOstunGbXUpp7HdBrFQX6rJzn3sPT397Wp5aCwCHg==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/postcss" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "dependencies": { + "nanoid": "^3.3.11", + "picocolors": "^1.1.1", + "source-map-js": "^1.2.1" + }, + "engines": { + "node": "^10 || ^12 || >=14" + } + }, + "node_modules/punycode": { + "version": "2.3.1", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/punycode/-/punycode-2.3.1.tgz", + "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/require-from-string": { + "version": "2.0.2", + "resolved": "https://npm.apple.com/require-from-string/-/require-from-string-2.0.2.tgz", + "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==", + "dev": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/rollup": { + "version": "4.60.0", + "resolved": "https://npm.apple.com/rollup/-/rollup-4.60.0.tgz", + "integrity": "sha512-yqjxruMGBQJ2gG4HtjZtAfXArHomazDHoFwFFmZZl0r7Pdo7qCIXKqKHZc8yeoMgzJJ+pO6pEEHa+V7uzWlrAQ==", + "dev": true, + "dependencies": { + "@types/estree": "1.0.8" + }, + "bin": { + "rollup": "dist/bin/rollup" + }, + "engines": { + "node": ">=18.0.0", + "npm": ">=8.0.0" + }, + "optionalDependencies": { + "@rollup/rollup-android-arm-eabi": "4.60.0", + "@rollup/rollup-android-arm64": "4.60.0", + "@rollup/rollup-darwin-arm64": "4.60.0", + "@rollup/rollup-darwin-x64": "4.60.0", + "@rollup/rollup-freebsd-arm64": "4.60.0", + "@rollup/rollup-freebsd-x64": "4.60.0", + "@rollup/rollup-linux-arm-gnueabihf": "4.60.0", + "@rollup/rollup-linux-arm-musleabihf": "4.60.0", + "@rollup/rollup-linux-arm64-gnu": "4.60.0", + "@rollup/rollup-linux-arm64-musl": "4.60.0", + "@rollup/rollup-linux-loong64-gnu": "4.60.0", + "@rollup/rollup-linux-loong64-musl": "4.60.0", + "@rollup/rollup-linux-ppc64-gnu": "4.60.0", + "@rollup/rollup-linux-ppc64-musl": "4.60.0", + "@rollup/rollup-linux-riscv64-gnu": "4.60.0", + "@rollup/rollup-linux-riscv64-musl": "4.60.0", + "@rollup/rollup-linux-s390x-gnu": "4.60.0", + "@rollup/rollup-linux-x64-gnu": "4.60.0", + "@rollup/rollup-linux-x64-musl": "4.60.0", + "@rollup/rollup-openbsd-x64": "4.60.0", + "@rollup/rollup-openharmony-arm64": "4.60.0", + "@rollup/rollup-win32-arm64-msvc": "4.60.0", + "@rollup/rollup-win32-ia32-msvc": "4.60.0", + "@rollup/rollup-win32-x64-gnu": "4.60.0", + "@rollup/rollup-win32-x64-msvc": "4.60.0", + "fsevents": "~2.3.2" + } + }, + "node_modules/saxes": { + "version": "6.0.0", + "resolved": "https://npm.apple.com/saxes/-/saxes-6.0.0.tgz", + "integrity": "sha512-xAg7SOnEhrm5zI3puOOKyy1OMcMlIJZYNJY7xLBwSze0UjhPLnWfj2GF2EpT0jmzaJKIWKHLsaSSajf35bcYnA==", + "dev": true, + "dependencies": { + "xmlchars": "^2.2.0" + }, + "engines": { + "node": ">=v12.22.7" + } + }, + "node_modules/siginfo": { + "version": "2.0.0", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/siginfo/-/siginfo-2.0.0.tgz", + "integrity": "sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==", + "dev": true, + "license": "ISC" + }, + "node_modules/source-map-js": { + "version": "1.2.1", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/source-map-js/-/source-map-js-1.2.1.tgz", + "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==", + "dev": true, + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/stackback": { + "version": "0.0.2", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/stackback/-/stackback-0.0.2.tgz", + "integrity": "sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==", + "dev": true, + "license": "MIT" + }, + "node_modules/std-env": { + "version": "3.10.0", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/std-env/-/std-env-3.10.0.tgz", + "integrity": "sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==", + "dev": true, + "license": "MIT" + }, + "node_modules/strip-literal": { + "version": "3.1.0", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/strip-literal/-/strip-literal-3.1.0.tgz", + "integrity": "sha512-8r3mkIM/2+PpjHoOtiAW8Rg3jJLHaV7xPwG+YRGrv6FP0wwk/toTpATxWYOW0BKdWwl82VT2tFYi5DlROa0Mxg==", + "dev": true, + "license": "MIT", + "dependencies": { + "js-tokens": "^9.0.1" + }, + "funding": { + "url": "https://github.com/sponsors/antfu" + } + }, + "node_modules/symbol-tree": { + "version": "3.2.4", + "resolved": "https://npm.apple.com/symbol-tree/-/symbol-tree-3.2.4.tgz", + "integrity": "sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==", + "dev": true + }, + "node_modules/tinybench": { + "version": "2.9.0", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/tinybench/-/tinybench-2.9.0.tgz", + "integrity": "sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==", + "dev": true, + "license": "MIT" + }, + "node_modules/tinyexec": { + "version": "0.3.2", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/tinyexec/-/tinyexec-0.3.2.tgz", + "integrity": "sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA==", + "dev": true, + "license": "MIT" + }, + "node_modules/tinyglobby": { + "version": "0.2.15", + "resolved": "https://npm.apple.com/tinyglobby/-/tinyglobby-0.2.15.tgz", + "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==", + "dev": true, + "dependencies": { + "fdir": "^6.5.0", + "picomatch": "^4.0.3" + }, + "engines": { + "node": ">=12.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/SuperchupuDev" + } + }, + "node_modules/tinypool": { + "version": "1.1.1", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/tinypool/-/tinypool-1.1.1.tgz", + "integrity": "sha512-Zba82s87IFq9A9XmjiX5uZA/ARWDrB03OHlq+Vw1fSdt0I+4/Kutwy8BP4Y/y/aORMo61FQ0vIb5j44vSo5Pkg==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^18.0.0 || >=20.0.0" + } + }, + "node_modules/tinyrainbow": { + "version": "2.0.0", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/tinyrainbow/-/tinyrainbow-2.0.0.tgz", + "integrity": "sha512-op4nsTR47R6p0vMUUoYl/a+ljLFVtlfaXkLQmqfLR1qHma1h/ysYk4hEXZ880bf2CYgTskvTa/e196Vd5dDQXw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/tinyspy": { + "version": "4.0.4", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/tinyspy/-/tinyspy-4.0.4.tgz", + "integrity": "sha512-azl+t0z7pw/z958Gy9svOTuzqIk6xq+NSheJzn5MMWtWTFywIacg2wUlzKFGtt3cthx0r2SxMK0yzJOR0IES7Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/tldts": { + "version": "7.0.27", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/tldts/-/tldts-7.0.27.tgz", + "integrity": "sha512-I4FZcVFcqCRuT0ph6dCDpPuO4Xgzvh+spkcTr1gK7peIvxWauoloVO0vuy1FQnijT63ss6AsHB6+OIM4aXHbPg==", + "dev": true, + "license": "MIT", + "dependencies": { + "tldts-core": "^7.0.27" + }, + "bin": { + "tldts": "bin/cli.js" + } + }, + "node_modules/tldts-core": { + "version": "7.0.27", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/tldts-core/-/tldts-core-7.0.27.tgz", + "integrity": "sha512-YQ7uPjgWUibIK6DW5lrKujGwUKhLevU4hcGbP5O6TcIUb+oTjJYJVWPS4nZsIHrEEEG6myk/oqAJUEQmpZrHsg==", + "dev": true, + "license": "MIT" + }, + "node_modules/tough-cookie": { + "version": "6.0.1", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/tough-cookie/-/tough-cookie-6.0.1.tgz", + "integrity": "sha512-LktZQb3IeoUWB9lqR5EWTHgW/VTITCXg4D21M+lvybRVdylLrRMnqaIONLVb5mav8vM19m44HIcGq4qASeu2Qw==", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "tldts": "^7.0.5" + }, + "engines": { + "node": ">=16" + } + }, + "node_modules/tr46": { + "version": "6.0.0", + "resolved": "https://npm.apple.com/tr46/-/tr46-6.0.0.tgz", + "integrity": "sha512-bLVMLPtstlZ4iMQHpFHTR7GAGj2jxi8Dg0s2h2MafAE4uSWF98FC/3MomU51iQAMf8/qDUbKWf5GxuvvVcXEhw==", + "dev": true, + "dependencies": { + "punycode": "^2.3.1" + }, + "engines": { + "node": ">=20" + } + }, + "node_modules/typescript": { + "version": "5.9.3", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/typescript/-/typescript-5.9.3.tgz", + "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=14.17" + } + }, + "node_modules/undici": { + "version": "7.24.6", + "resolved": "https://npm.apple.com/undici/-/undici-7.24.6.tgz", + "integrity": "sha512-Xi4agocCbRzt0yYMZGMA6ApD7gvtUFaxm4ZmeacWI4cZxaF6C+8I8QfofC20NAePiB/IcvZmzkJ7XPa471AEtA==", + "dev": true, + "engines": { + "node": ">=20.18.1" + } + }, + "node_modules/vite": { + "version": "6.4.1", + "resolved": "https://npm.apple.com/vite/-/vite-6.4.1.tgz", + "integrity": "sha512-+Oxm7q9hDoLMyJOYfUYBuHQo+dkAloi33apOPP56pzj+vsdJDzr+j1NISE5pyaAuKL4A3UD34qd0lx5+kfKp2g==", + "dev": true, + "dependencies": { + "esbuild": "^0.25.0", + "fdir": "^6.4.4", + "picomatch": "^4.0.2", + "postcss": "^8.5.3", + "rollup": "^4.34.9", + "tinyglobby": "^0.2.13" + }, + "bin": { + "vite": "bin/vite.js" + }, + "engines": { + "node": "^18.0.0 || ^20.0.0 || >=22.0.0" + }, + "funding": { + "url": "https://github.com/vitejs/vite?sponsor=1" + }, + "optionalDependencies": { + "fsevents": "~2.3.3" + }, + "peerDependencies": { + "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0", + "jiti": ">=1.21.0", + "less": "*", + "lightningcss": "^1.21.0", + "sass": "*", + "sass-embedded": "*", + "stylus": "*", + "sugarss": "*", + "terser": "^5.16.0", + "tsx": "^4.8.1", + "yaml": "^2.4.2" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + }, + "jiti": { + "optional": true + }, + "less": { + "optional": true + }, + "lightningcss": { + "optional": true + }, + "sass": { + "optional": true + }, + "sass-embedded": { + "optional": true + }, + "stylus": { + "optional": true + }, + "sugarss": { + "optional": true + }, + "terser": { + "optional": true + }, + "tsx": { + "optional": true + }, + "yaml": { + "optional": true + } + } + }, + "node_modules/vite-node": { + "version": "3.2.4", + "resolved": "https://npm.apple.com/vite-node/-/vite-node-3.2.4.tgz", + "integrity": "sha512-EbKSKh+bh1E1IFxeO0pg1n4dvoOTt0UDiXMd/qn++r98+jPO1xtJilvXldeuQ8giIB5IkpjCgMleHMNEsGH6pg==", + "dev": true, + "dependencies": { + "cac": "^6.7.14", + "debug": "^4.4.1", + "es-module-lexer": "^1.7.0", + "pathe": "^2.0.3", + "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0" + }, + "bin": { + "vite-node": "vite-node.mjs" + }, + "engines": { + "node": "^18.0.0 || ^20.0.0 || >=22.0.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/vitest": { + "version": "3.2.4", + "resolved": "https://npm.apple.com/vitest/-/vitest-3.2.4.tgz", + "integrity": "sha512-LUCP5ev3GURDysTWiP47wRRUpLKMOfPh+yKTx3kVIEiu5KOMeqzpnYNsKyOoVrULivR8tLcks4+lga33Whn90A==", + "dev": true, + "dependencies": { + "@types/chai": "^5.2.2", + "@vitest/expect": "3.2.4", + "@vitest/mocker": "3.2.4", + "@vitest/pretty-format": "^3.2.4", + "@vitest/runner": "3.2.4", + "@vitest/snapshot": "3.2.4", + "@vitest/spy": "3.2.4", + "@vitest/utils": "3.2.4", + "chai": "^5.2.0", + "debug": "^4.4.1", + "expect-type": "^1.2.1", + "magic-string": "^0.30.17", + "pathe": "^2.0.3", + "picomatch": "^4.0.2", + "std-env": "^3.9.0", + "tinybench": "^2.9.0", + "tinyexec": "^0.3.2", + "tinyglobby": "^0.2.14", + "tinypool": "^1.1.1", + "tinyrainbow": "^2.0.0", + "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0", + "vite-node": "3.2.4", + "why-is-node-running": "^2.3.0" + }, + "bin": { + "vitest": "vitest.mjs" + }, + "engines": { + "node": "^18.0.0 || ^20.0.0 || >=22.0.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + }, + "peerDependencies": { + "@edge-runtime/vm": "*", + "@types/debug": "^4.1.12", + "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0", + "@vitest/browser": "3.2.4", + "@vitest/ui": "3.2.4", + "happy-dom": "*", + "jsdom": "*" + }, + "peerDependenciesMeta": { + "@edge-runtime/vm": { + "optional": true + }, + "@types/debug": { + "optional": true + }, + "@types/node": { + "optional": true + }, + "@vitest/browser": { + "optional": true + }, + "@vitest/ui": { + "optional": true + }, + "happy-dom": { + "optional": true + }, + "jsdom": { + "optional": true + } + } + }, + "node_modules/w3c-xmlserializer": { + "version": "5.0.0", + "resolved": "https://npm.apple.com/w3c-xmlserializer/-/w3c-xmlserializer-5.0.0.tgz", + "integrity": "sha512-o8qghlI8NZHU1lLPrpi2+Uq7abh4GGPpYANlalzWxyWteJOCsr/P+oPBA49TOLu5FTZO4d3F9MnWJfiMo4BkmA==", + "dev": true, + "dependencies": { + "xml-name-validator": "^5.0.0" + }, + "engines": { + "node": ">=18" + } + }, + "node_modules/webidl-conversions": { + "version": "8.0.1", + "resolved": "https://npm.apple.com/webidl-conversions/-/webidl-conversions-8.0.1.tgz", + "integrity": "sha512-BMhLD/Sw+GbJC21C/UgyaZX41nPt8bUTg+jWyDeg7e7YN4xOM05YPSIXceACnXVtqyEw/LMClUQMtMZ+PGGpqQ==", + "dev": true, + "engines": { + "node": ">=20" + } + }, + "node_modules/whatwg-mimetype": { + "version": "5.0.0", + "resolved": "https://npm.apple.com/whatwg-mimetype/-/whatwg-mimetype-5.0.0.tgz", + "integrity": "sha512-sXcNcHOC51uPGF0P/D4NVtrkjSU2fNsm9iog4ZvZJsL3rjoDAzXZhkm2MWt1y+PUdggKAYVoMAIYcs78wJ51Cw==", + "dev": true, + "engines": { + "node": ">=20" + } + }, + "node_modules/whatwg-url": { + "version": "16.0.1", + "resolved": "https://npm.apple.com/whatwg-url/-/whatwg-url-16.0.1.tgz", + "integrity": "sha512-1to4zXBxmXHV3IiSSEInrreIlu02vUOvrhxJJH5vcxYTBDAx51cqZiKdyTxlecdKNSjj8EcxGBxNf6Vg+945gw==", + "dev": true, + "dependencies": { + "@exodus/bytes": "^1.11.0", + "tr46": "^6.0.0", + "webidl-conversions": "^8.0.1" + }, + "engines": { + "node": "^20.19.0 || ^22.12.0 || >=24.0.0" + } + }, + "node_modules/why-is-node-running": { + "version": "2.3.0", + "resolved": "https://artifacts.apple.com/artifactory/api/npm/npm-apple/why-is-node-running/-/why-is-node-running-2.3.0.tgz", + "integrity": "sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==", + "dev": true, + "license": "MIT", + "dependencies": { + "siginfo": "^2.0.0", + "stackback": "0.0.2" + }, + "bin": { + "why-is-node-running": "cli.js" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/xml-name-validator": { + "version": "5.0.0", + "resolved": "https://npm.apple.com/xml-name-validator/-/xml-name-validator-5.0.0.tgz", + "integrity": "sha512-EvGK8EJ3DhaHfbRlETOWAS5pO9MZITeauHKJyb8wyajUfQUenkIg2MvLDTZ4T/TgIcm3HU0TFBgWWboAZ30UHg==", + "dev": true, + "engines": { + "node": ">=18" + } + }, + "node_modules/xmlchars": { + "version": "2.2.0", + "resolved": "https://npm.apple.com/xmlchars/-/xmlchars-2.2.0.tgz", + "integrity": "sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw==", + "dev": true + } + } +} diff --git a/lnt/server/ui/v5/frontend/package.json b/lnt/server/ui/v5/frontend/package.json new file mode 100644 index 000000000..59f82b603 --- /dev/null +++ b/lnt/server/ui/v5/frontend/package.json @@ -0,0 +1,14 @@ +{ + "name": "lnt-frontend", + "private": true, + "scripts": { + "build": "vite build", + "test": "vitest run" + }, + "devDependencies": { + "jsdom": "^29.0.1", + "typescript": "^5.7.0", + "vite": "^6.0.0", + "vitest": "^3.0.0" + } +} diff --git a/lnt/server/ui/v5/frontend/src/__tests__/api.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/api.test.ts new file mode 100644 index 000000000..7792d55d5 --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/__tests__/api.test.ts @@ -0,0 +1,1013 @@ +import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; +import { setApiBase, getFields, getOrders, getMachines, getRuns, getSamples, + getMachine, getMachineRuns, deleteMachine, getRun, deleteRun, getOrder, getRunsByOrder, getRecentRuns, + getFieldChanges, searchOrdersByTag, updateOrderTag, queryDataPoints, + fetchOneCursorPage, apiUrl, ApiError, authErrorMessage, +} from '../api'; +import type { + CursorPaginated, FieldInfo, MachineInfo, MachineRunInfo, OffsetPaginated, + OrderSummary, OrderDetail, RunInfo, RunDetail, SampleInfo, FieldChangeInfo, + QueryDataPoint, +} from '../types'; + +// --------------------------------------------------------------------------- +// Helpers to build mock paginated responses +// --------------------------------------------------------------------------- + +function cursorPage<T>(items: T[], next: string | null = null): CursorPaginated<T> { + return { items, cursor: { next, previous: null } }; +} + +function offsetPage<T>(items: T[], total: number): OffsetPaginated<T> { + return { items, total, cursor: { next: null, previous: null } }; +} + +// --------------------------------------------------------------------------- +// Global mocks – fetch, localStorage, window.location +// --------------------------------------------------------------------------- + +let mockFetch: ReturnType<typeof vi.fn>; +let storedToken: string | null; + +function mockResponse(body: unknown, status = 200, statusText = 'OK'): Response { + return { + ok: status >= 200 && status < 300, + status, + statusText, + json: () => Promise.resolve(body), + text: () => Promise.resolve(typeof body === 'string' ? body : JSON.stringify(body)), + headers: new Headers(), + redirected: false, + type: 'basic' as ResponseType, + url: '', + clone: () => mockResponse(body, status, statusText), + body: null, + bodyUsed: false, + arrayBuffer: () => Promise.resolve(new ArrayBuffer(0)), + blob: () => Promise.resolve(new Blob()), + formData: () => Promise.resolve(new FormData()), + bytes: () => Promise.resolve(new Uint8Array()), + } as Response; +} + +beforeEach(() => { + storedToken = null; + + mockFetch = vi.fn(); + vi.stubGlobal('fetch', mockFetch); + + vi.stubGlobal('localStorage', { + getItem: (key: string) => key === 'lnt_v5_token' ? storedToken : null, + setItem: vi.fn(), + removeItem: vi.fn(), + clear: vi.fn(), + length: 0, + key: () => null, + }); + + // api.ts references `window.location.origin` — we need the `window` global + // to exist in Node. stubGlobal('window', ...) creates globalThis.window. + vi.stubGlobal('window', { + location: { origin: 'http://localhost:3000' }, + }); + + // Reset apiBase before each test + setApiBase(''); +}); + +afterEach(() => { + vi.restoreAllMocks(); + vi.unstubAllGlobals(); +}); + +// =========================================================================== +// setApiBase +// =========================================================================== + +describe('setApiBase', () => { + it('sets base URL used in subsequent requests', async () => { + setApiBase('/lnt'); + mockFetch.mockResolvedValueOnce(mockResponse({ schema: { metrics: [] } })); + + await getFields('nts'); + + const url = new URL(mockFetch.mock.calls[0][0]); + expect(url.pathname).toBe('/lnt/api/v5/test-suites/nts'); + }); + + it('strips trailing slash from base', async () => { + setApiBase('/lnt/'); + mockFetch.mockResolvedValueOnce(mockResponse({ schema: { metrics: [] } })); + + await getFields('nts'); + + const url = new URL(mockFetch.mock.calls[0][0]); + expect(url.pathname).toBe('/lnt/api/v5/test-suites/nts'); + }); + + it('handles empty string base', async () => { + setApiBase(''); + mockFetch.mockResolvedValueOnce(mockResponse({ schema: { metrics: [] } })); + + await getFields('nts'); + + const url = new URL(mockFetch.mock.calls[0][0]); + expect(url.pathname).toBe('/api/v5/test-suites/nts'); + }); +}); + +// =========================================================================== +// Auth header injection +// =========================================================================== + +describe('auth header injection', () => { + it('includes Bearer token when localStorage has a token', async () => { + storedToken = 'my-secret-token'; + mockFetch.mockResolvedValueOnce(mockResponse({ schema: { metrics: [] } })); + + await getFields('nts'); + + const headers = mockFetch.mock.calls[0][1].headers; + expect(headers['Authorization']).toBe('Bearer my-secret-token'); + expect(headers['Accept']).toBe('application/json'); + }); + + it('omits Authorization header when no token is stored', async () => { + storedToken = null; + mockFetch.mockResolvedValueOnce(mockResponse({ schema: { metrics: [] } })); + + await getFields('nts'); + + const headers = mockFetch.mock.calls[0][1].headers; + expect(headers['Authorization']).toBeUndefined(); + expect(headers['Accept']).toBe('application/json'); + }); +}); + +// =========================================================================== +// Error formatting +// =========================================================================== + +describe('error formatting', () => { + it('throws an Error with status and body text on non-OK response', async () => { + mockFetch.mockResolvedValueOnce( + mockResponse('{"error":"not found"}', 404, 'Not Found') + ); + + await expect(getFields('nts')).rejects.toThrow('API 404: {"error":"not found"}'); + }); + + it('falls back to statusText when body text is empty', async () => { + const resp = { + ok: false, + status: 500, + statusText: 'Internal Server Error', + text: () => Promise.resolve(''), + json: () => Promise.reject(new Error('no json')), + headers: new Headers(), + redirected: false, + type: 'basic' as ResponseType, + url: '', + clone: () => resp, + body: null, + bodyUsed: false, + arrayBuffer: () => Promise.resolve(new ArrayBuffer(0)), + blob: () => Promise.resolve(new Blob()), + formData: () => Promise.resolve(new FormData()), + bytes: () => Promise.resolve(new Uint8Array()), + } as Response; + + mockFetch.mockResolvedValueOnce(resp); + + await expect(getFields('nts')).rejects.toThrow('API 500: Internal Server Error'); + }); + + it('falls back to statusText when resp.text() rejects', async () => { + const resp = { + ok: false, + status: 502, + statusText: 'Bad Gateway', + text: () => Promise.reject(new Error('stream error')), + json: () => Promise.reject(new Error('no json')), + headers: new Headers(), + redirected: false, + type: 'basic' as ResponseType, + url: '', + clone: () => resp, + body: null, + bodyUsed: false, + arrayBuffer: () => Promise.resolve(new ArrayBuffer(0)), + blob: () => Promise.resolve(new Blob()), + formData: () => Promise.resolve(new FormData()), + bytes: () => Promise.resolve(new Uint8Array()), + } as Response; + + mockFetch.mockResolvedValueOnce(resp); + + await expect(getFields('nts')).rejects.toThrow('API 502: Bad Gateway'); + }); +}); + +// =========================================================================== +// AbortSignal +// =========================================================================== + +describe('AbortSignal support', () => { + it('passes signal to fetch for non-paginated requests', async () => { + const controller = new AbortController(); + mockFetch.mockResolvedValueOnce(mockResponse({ schema: { metrics: [] } })); + + await getFields('nts', controller.signal); + + expect(mockFetch.mock.calls[0][1].signal).toBe(controller.signal); + }); + + it('passes signal to every fetch call in paginated requests', async () => { + const controller = new AbortController(); + mockFetch + .mockResolvedValueOnce(mockResponse(cursorPage([{ fields: { llvm_project_revision: '100' } }], 'cursor1'))) + .mockResolvedValueOnce(mockResponse(cursorPage([{ fields: { llvm_project_revision: '200' } }]))); + + await getOrders('nts', controller.signal); + + expect(mockFetch.mock.calls).toHaveLength(2); + expect(mockFetch.mock.calls[0][1].signal).toBe(controller.signal); + expect(mockFetch.mock.calls[1][1].signal).toBe(controller.signal); + }); +}); + +// =========================================================================== +// Cursor-based pagination loop +// =========================================================================== + +describe('cursor-based pagination', () => { + it('fetches a single page when cursor.next is null', async () => { + const order: OrderSummary = { fields: { llvm_project_revision: '100' } }; + mockFetch.mockResolvedValueOnce(mockResponse(cursorPage([order]))); + + const result = await getOrders('nts'); + + expect(result).toEqual([order]); + expect(mockFetch).toHaveBeenCalledTimes(1); + }); + + it('fetches multiple pages and concatenates results', async () => { + const o1: OrderSummary = { fields: { llvm_project_revision: '100' } }; + const o2: OrderSummary = { fields: { llvm_project_revision: '200' } }; + const o3: OrderSummary = { fields: { llvm_project_revision: '300' } }; + + mockFetch + .mockResolvedValueOnce(mockResponse(cursorPage([o1], 'cursor-abc'))) + .mockResolvedValueOnce(mockResponse(cursorPage([o2], 'cursor-def'))) + .mockResolvedValueOnce(mockResponse(cursorPage([o3]))); + + const result = await getOrders('nts'); + + expect(result).toEqual([o1, o2, o3]); + expect(mockFetch).toHaveBeenCalledTimes(3); + }); + + it('passes cursor parameter on subsequent pages', async () => { + mockFetch + .mockResolvedValueOnce(mockResponse(cursorPage([{ fields: { rev: '1' } }], 'next-page-cursor'))) + .mockResolvedValueOnce(mockResponse(cursorPage([{ fields: { rev: '2' } }]))); + + await getOrders('nts'); + + // First call should have no cursor + const firstUrl = new URL(mockFetch.mock.calls[0][0]); + expect(firstUrl.searchParams.has('cursor')).toBe(false); + expect(firstUrl.searchParams.get('limit')).toBe('500'); + + // Second call should include the cursor + const secondUrl = new URL(mockFetch.mock.calls[1][0]); + expect(secondUrl.searchParams.get('cursor')).toBe('next-page-cursor'); + expect(secondUrl.searchParams.get('limit')).toBe('500'); + }); + + it('calls onProgress callback with running total after each page', async () => { + mockFetch + .mockResolvedValueOnce(mockResponse(cursorPage([{ fields: { rev: '1' } }, { fields: { rev: '2' } }], 'c1'))) + .mockResolvedValueOnce(mockResponse(cursorPage([{ fields: { rev: '3' } }]))); + + const onProgress = vi.fn(); + await getOrders('nts', undefined, onProgress); + + expect(onProgress).toHaveBeenCalledTimes(2); + expect(onProgress).toHaveBeenNthCalledWith(1, 2); + expect(onProgress).toHaveBeenNthCalledWith(2, 3); + }); + + it('stops paginating when error occurs mid-pagination', async () => { + mockFetch + .mockResolvedValueOnce(mockResponse(cursorPage([{ fields: { rev: '1' } }], 'c1'))) + .mockResolvedValueOnce(mockResponse('server error', 500, 'Internal Server Error')); + + await expect(getOrders('nts')).rejects.toThrow('API 500'); + expect(mockFetch).toHaveBeenCalledTimes(2); + }); +}); + +// =========================================================================== +// getFields +// =========================================================================== + +describe('getFields', () => { + it('returns the metrics array from the test-suite schema', async () => { + const fields: FieldInfo[] = [ + { name: 'compile_time', type: 'Real', display_name: 'Compile Time', unit: 'seconds', unit_abbrev: 's', bigger_is_better: false }, + { name: 'exec_time', type: 'Real', display_name: 'Execution Time', unit: 'seconds', unit_abbrev: 's', bigger_is_better: false }, + ]; + mockFetch.mockResolvedValueOnce(mockResponse({ schema: { metrics: fields } })); + + const result = await getFields('nts'); + + expect(result).toEqual(fields); + }); + + it('constructs the correct URL', async () => { + mockFetch.mockResolvedValueOnce(mockResponse({ schema: { metrics: [] } })); + + await getFields('nts'); + + const url = new URL(mockFetch.mock.calls[0][0]); + expect(url.pathname).toBe('/api/v5/test-suites/nts'); + }); + + it('encodes test suite name in URL', async () => { + mockFetch.mockResolvedValueOnce(mockResponse({ schema: { metrics: [] } })); + + await getFields('my test suite'); + + const url = new URL(mockFetch.mock.calls[0][0]); + expect(url.pathname).toBe('/api/v5/test-suites/my%20test%20suite'); + }); +}); + +// =========================================================================== +// getOrders +// =========================================================================== + +describe('getOrders', () => { + it('returns all orders across multiple pages', async () => { + const o1: OrderSummary = { fields: { llvm_project_revision: '100' } }; + const o2: OrderSummary = { fields: { llvm_project_revision: '200' } }; + + mockFetch + .mockResolvedValueOnce(mockResponse(cursorPage([o1], 'c1'))) + .mockResolvedValueOnce(mockResponse(cursorPage([o2]))); + + const result = await getOrders('nts'); + expect(result).toEqual([o1, o2]); + }); + + it('constructs the correct URL with limit=500', async () => { + mockFetch.mockResolvedValueOnce(mockResponse(cursorPage([]))); + + await getOrders('nts'); + + const url = new URL(mockFetch.mock.calls[0][0]); + expect(url.pathname).toBe('/api/v5/nts/orders'); + expect(url.searchParams.get('limit')).toBe('500'); + }); +}); + +// =========================================================================== +// getMachines +// =========================================================================== + +describe('getMachines', () => { + it('returns items and total from offset-paginated response', async () => { + const machines: MachineInfo[] = [ + { name: 'machine-1', info: { os: 'linux' } }, + { name: 'machine-2', info: { os: 'darwin' } }, + ]; + mockFetch.mockResolvedValueOnce(mockResponse(offsetPage(machines, 42))); + + const result = await getMachines('nts', {}); + + expect(result.items).toEqual(machines); + expect(result.total).toBe(42); + }); + + it('passes namePrefix as name_prefix query param', async () => { + mockFetch.mockResolvedValueOnce(mockResponse(offsetPage([], 0))); + + await getMachines('nts', { namePrefix: 'clang-' }); + + const url = new URL(mockFetch.mock.calls[0][0]); + expect(url.searchParams.get('name_prefix')).toBe('clang-'); + }); + + it('passes limit query param', async () => { + mockFetch.mockResolvedValueOnce(mockResponse(offsetPage([], 0))); + + await getMachines('nts', { limit: 10 }); + + const url = new URL(mockFetch.mock.calls[0][0]); + expect(url.searchParams.get('limit')).toBe('10'); + }); + + it('omits namePrefix and limit when not provided', async () => { + mockFetch.mockResolvedValueOnce(mockResponse(offsetPage([], 0))); + + await getMachines('nts', {}); + + const url = new URL(mockFetch.mock.calls[0][0]); + expect(url.searchParams.has('name_prefix')).toBe(false); + expect(url.searchParams.has('limit')).toBe(false); + }); + + it('constructs the correct URL path', async () => { + mockFetch.mockResolvedValueOnce(mockResponse(offsetPage([], 0))); + + await getMachines('nts', {}); + + const url = new URL(mockFetch.mock.calls[0][0]); + expect(url.pathname).toBe('/api/v5/nts/machines'); + }); + + it('passes nameContains as name_contains query param', async () => { + mockFetch.mockResolvedValueOnce(mockResponse(offsetPage([], 0))); + + await getMachines('nts', { nameContains: 'clang' }); + + const url = new URL(mockFetch.mock.calls[0][0]); + expect(url.searchParams.get('name_contains')).toBe('clang'); + }); + + it('passes offset query param', async () => { + mockFetch.mockResolvedValueOnce(mockResponse(offsetPage([], 0))); + + await getMachines('nts', { offset: 25 }); + + const url = new URL(mockFetch.mock.calls[0][0]); + expect(url.searchParams.get('offset')).toBe('25'); + }); +}); + +// =========================================================================== +// getRuns +// =========================================================================== + +describe('getRuns', () => { + it('returns all runs across paginated responses', async () => { + const r1: RunInfo = { + uuid: 'aaa-111', + machine: 'machine-1', + order: { llvm_project_revision: '100' }, + start_time: '2025-01-01T00:00:00', + end_time: '2025-01-01T01:00:00', + }; + const r2: RunInfo = { + uuid: 'bbb-222', + machine: 'machine-1', + order: { llvm_project_revision: '200' }, + start_time: null, + end_time: null, + }; + + mockFetch + .mockResolvedValueOnce(mockResponse(cursorPage([r1], 'next-c'))) + .mockResolvedValueOnce(mockResponse(cursorPage([r2]))); + + const result = await getRuns('nts', { machine: 'machine-1' }); + expect(result).toEqual([r1, r2]); + }); + + it('passes machine and order as query params', async () => { + mockFetch.mockResolvedValueOnce(mockResponse(cursorPage([]))); + + await getRuns('nts', { machine: 'machine-1', order: 'rev100' }); + + const url = new URL(mockFetch.mock.calls[0][0]); + expect(url.searchParams.get('machine')).toBe('machine-1'); + expect(url.searchParams.get('order')).toBe('rev100'); + expect(url.searchParams.get('limit')).toBe('500'); + }); + + it('omits order when not provided', async () => { + mockFetch.mockResolvedValueOnce(mockResponse(cursorPage([]))); + + await getRuns('nts', { machine: 'machine-1' }); + + const url = new URL(mockFetch.mock.calls[0][0]); + expect(url.searchParams.has('order')).toBe(false); + }); + + it('constructs the correct URL path', async () => { + mockFetch.mockResolvedValueOnce(mockResponse(cursorPage([]))); + + await getRuns('nts', { machine: 'machine-1' }); + + const url = new URL(mockFetch.mock.calls[0][0]); + expect(url.pathname).toBe('/api/v5/nts/runs'); + }); +}); + +// =========================================================================== +// getSamples +// =========================================================================== + +describe('getSamples', () => { + it('returns all samples across paginated responses', async () => { + const s1: SampleInfo = { test: 'test/a', has_profile: false, metrics: { compile_time: 1.23 } }; + const s2: SampleInfo = { test: 'test/b', has_profile: true, metrics: { compile_time: null } }; + + mockFetch + .mockResolvedValueOnce(mockResponse(cursorPage([s1], 'c1'))) + .mockResolvedValueOnce(mockResponse(cursorPage([s2]))); + + const result = await getSamples('nts', 'run-uuid-123'); + expect(result).toEqual([s1, s2]); + }); + + it('constructs URL with encoded run UUID', async () => { + mockFetch.mockResolvedValueOnce(mockResponse(cursorPage([]))); + + await getSamples('nts', 'abc-def/special'); + + const url = new URL(mockFetch.mock.calls[0][0]); + expect(url.pathname).toBe('/api/v5/nts/runs/abc-def%2Fspecial/samples'); + }); + + it('calls onProgress with running total', async () => { + mockFetch + .mockResolvedValueOnce(mockResponse(cursorPage( + [{ test: 'a', has_profile: false, metrics: {} }, { test: 'b', has_profile: false, metrics: {} }], + 'c1', + ))) + .mockResolvedValueOnce(mockResponse(cursorPage( + [{ test: 'c', has_profile: false, metrics: {} }], + ))); + + const onProgress = vi.fn(); + await getSamples('nts', 'run-uuid', undefined, onProgress); + + expect(onProgress).toHaveBeenCalledTimes(2); + expect(onProgress).toHaveBeenNthCalledWith(1, 2); + expect(onProgress).toHaveBeenNthCalledWith(2, 3); + }); + + it('passes signal through paginated requests', async () => { + const controller = new AbortController(); + mockFetch.mockResolvedValueOnce(mockResponse(cursorPage([]))); + + await getSamples('nts', 'run-uuid', controller.signal); + + expect(mockFetch.mock.calls[0][1].signal).toBe(controller.signal); + }); +}); + +// =========================================================================== +// URL construction – apiUrl encodes test suite names +// =========================================================================== + +describe('URL construction', () => { + it('encodes special characters in test suite name', async () => { + mockFetch.mockResolvedValueOnce(mockResponse({ schema: { metrics: [] } })); + + await getFields('nts/special chars'); + + const url = new URL(mockFetch.mock.calls[0][0]); + expect(url.pathname).toBe('/api/v5/test-suites/nts%2Fspecial%20chars'); + }); + + it('uses apiBase prefix for all API functions', async () => { + setApiBase('/myapp'); + + // Test each function constructs URLs with the base + mockFetch.mockResolvedValueOnce(mockResponse({ schema: { metrics: [] } })); + await getFields('nts'); + expect(new URL(mockFetch.mock.calls[0][0]).pathname).toBe('/myapp/api/v5/test-suites/nts'); + + mockFetch.mockResolvedValueOnce(mockResponse(cursorPage([]))); + await getOrders('nts'); + expect(new URL(mockFetch.mock.calls[1][0]).pathname).toBe('/myapp/api/v5/nts/orders'); + + mockFetch.mockResolvedValueOnce(mockResponse(offsetPage([], 0))); + await getMachines('nts', {}); + expect(new URL(mockFetch.mock.calls[2][0]).pathname).toBe('/myapp/api/v5/nts/machines'); + + mockFetch.mockResolvedValueOnce(mockResponse(cursorPage([]))); + await getRuns('nts', { machine: 'm' }); + expect(new URL(mockFetch.mock.calls[3][0]).pathname).toBe('/myapp/api/v5/nts/runs'); + + mockFetch.mockResolvedValueOnce(mockResponse(cursorPage([]))); + await getSamples('nts', 'uuid-1'); + expect(new URL(mockFetch.mock.calls[4][0]).pathname).toBe('/myapp/api/v5/nts/runs/uuid-1/samples'); + }); +}); + +// =========================================================================== +// fetchJson – query parameter handling +// =========================================================================== + +describe('query parameter handling', () => { + it('omits empty string params', async () => { + // getRuns with empty order should not include it + mockFetch.mockResolvedValueOnce(mockResponse(cursorPage([]))); + + await getRuns('nts', { machine: 'machine-1', order: '' }); + + const url = new URL(mockFetch.mock.calls[0][0]); + expect(url.searchParams.get('machine')).toBe('machine-1'); + // order is '' and should be excluded by the fetchJson params filtering + // (but actually getRuns conditionally adds order, so let's test via getMachines) + expect(url.searchParams.has('order')).toBe(false); + }); +}); + +// =========================================================================== +// Phase 2: New API functions +// =========================================================================== + +describe('getMachine', () => { + it('fetches a single machine by name', async () => { + const machine: MachineInfo = { name: 'clang-x86', info: { os: 'linux' } }; + mockFetch.mockResolvedValueOnce(mockResponse(machine)); + + const result = await getMachine('nts', 'clang-x86'); + + expect(result).toEqual(machine); + const url = new URL(mockFetch.mock.calls[0][0]); + expect(url.pathname).toBe('/api/v5/nts/machines/clang-x86'); + }); + + it('encodes machine name in URL', async () => { + mockFetch.mockResolvedValueOnce(mockResponse({ name: 'a/b', info: {} })); + await getMachine('nts', 'a/b'); + const url = new URL(mockFetch.mock.calls[0][0]); + expect(url.pathname).toBe('/api/v5/nts/machines/a%2Fb'); + }); +}); + +describe('getMachineRuns', () => { + it('fetches runs for a machine with sort and limit', async () => { + const page = cursorPage<MachineRunInfo>( + [{ uuid: 'r1', order: { rev: '100' }, start_time: null, end_time: null }], + 'cursor-2', + ); + mockFetch.mockResolvedValueOnce(mockResponse(page)); + + const result = await getMachineRuns('nts', 'clang-x86', { sort: '-start_time', limit: 10 }); + + expect(result.items).toHaveLength(1); + expect(result.cursor.next).toBe('cursor-2'); + const url = new URL(mockFetch.mock.calls[0][0]); + expect(url.pathname).toBe('/api/v5/nts/machines/clang-x86/runs'); + expect(url.searchParams.get('sort')).toBe('-start_time'); + expect(url.searchParams.get('limit')).toBe('10'); + }); + + it('passes cursor query param for pagination', async () => { + mockFetch.mockResolvedValueOnce(mockResponse(cursorPage<MachineRunInfo>([], null))); + + await getMachineRuns('nts', 'clang-x86', { cursor: 'abc123' }); + + const url = new URL(mockFetch.mock.calls[0][0]); + expect(url.searchParams.get('cursor')).toBe('abc123'); + }); +}); + +describe('deleteMachine', () => { + it('sends DELETE request to correct URL', async () => { + mockFetch.mockResolvedValueOnce(mockResponse('', 204)); + + await deleteMachine('nts', 'clang-x86'); + + expect(mockFetch).toHaveBeenCalledOnce(); + const url = new URL(mockFetch.mock.calls[0][0]); + expect(url.pathname).toBe('/api/v5/nts/machines/clang-x86'); + expect(mockFetch.mock.calls[0][1].method).toBe('DELETE'); + }); + + it('encodes machine name in URL', async () => { + mockFetch.mockResolvedValueOnce(mockResponse('', 204)); + + await deleteMachine('nts', 'machine with spaces'); + + const url = new URL(mockFetch.mock.calls[0][0]); + expect(url.pathname).toBe('/api/v5/nts/machines/machine%20with%20spaces'); + }); + + it('sends auth token when set', async () => { + storedToken = 'my-token'; + mockFetch.mockResolvedValueOnce(mockResponse('', 204)); + + await deleteMachine('nts', 'clang-x86'); + + expect(mockFetch.mock.calls[0][1].headers['Authorization']).toBe('Bearer my-token'); + }); + + it('throws ApiError on 403', async () => { + mockFetch.mockResolvedValueOnce(mockResponse('Forbidden', 403, 'Forbidden')); + + try { + await deleteMachine('nts', 'clang-x86'); + expect.fail('should have thrown'); + } catch (e) { + expect(e).toBeInstanceOf(ApiError); + expect((e as ApiError).status).toBe(403); + } + }); +}); + +describe('ApiError and authErrorMessage', () => { + it('authErrorMessage returns permission message for 401', () => { + expect(authErrorMessage(new ApiError(401, 'Unauthorized'))).toContain('Permission denied'); + }); + + it('authErrorMessage returns permission message for 403', () => { + expect(authErrorMessage(new ApiError(403, 'Forbidden'))).toContain('Permission denied'); + }); + + it('authErrorMessage returns generic message for other errors', () => { + expect(authErrorMessage(new Error('network failure'))).toContain('network failure'); + }); + + it('authErrorMessage returns generic message for non-auth ApiError', () => { + expect(authErrorMessage(new ApiError(500, 'Server error'))).toContain('Server error'); + }); +}); + +describe('getRun', () => { + it('fetches a single run by UUID', async () => { + const run: RunDetail = { + uuid: 'abc-123', machine: 'm1', order: { rev: '100' }, + start_time: '2025-01-01T00:00:00', end_time: null, parameters: {}, + }; + mockFetch.mockResolvedValueOnce(mockResponse(run)); + + const result = await getRun('nts', 'abc-123'); + + expect(result.uuid).toBe('abc-123'); + const url = new URL(mockFetch.mock.calls[0][0]); + expect(url.pathname).toBe('/api/v5/nts/runs/abc-123'); + }); +}); + +describe('deleteRun', () => { + it('sends DELETE request to correct URL', async () => { + mockFetch.mockResolvedValueOnce(mockResponse('', 204)); + + await deleteRun('nts', 'abc-123'); + + expect(mockFetch).toHaveBeenCalledOnce(); + const url = new URL(mockFetch.mock.calls[0][0]); + expect(url.pathname).toBe('/api/v5/nts/runs/abc-123'); + expect(mockFetch.mock.calls[0][1].method).toBe('DELETE'); + }); + + it('throws ApiError on 403', async () => { + mockFetch.mockResolvedValueOnce(mockResponse('Forbidden', 403, 'Forbidden')); + + try { + await deleteRun('nts', 'abc-123'); + expect.fail('should have thrown'); + } catch (e) { + expect(e).toBeInstanceOf(ApiError); + expect((e as ApiError).status).toBe(403); + } + }); +}); + +describe('getOrder', () => { + it('fetches order detail with prev/next and tag', async () => { + const order: OrderDetail = { + fields: { rev: '100' }, + tag: 'release-18', + previous_order: { fields: { rev: '99' }, link: '/api/v5/nts/orders/99' }, + next_order: null, + }; + mockFetch.mockResolvedValueOnce(mockResponse(order)); + + const result = await getOrder('nts', '100'); + + expect(result.tag).toBe('release-18'); + expect(result.previous_order).not.toBeNull(); + expect(result.next_order).toBeNull(); + const url = new URL(mockFetch.mock.calls[0][0]); + expect(url.pathname).toBe('/api/v5/nts/orders/100'); + }); +}); + +describe('getRunsByOrder', () => { + it('auto-paginates runs filtered by order value', async () => { + const run: RunInfo = { + uuid: 'r1', machine: 'm1', order: { rev: '100' }, + start_time: null, end_time: null, + }; + mockFetch.mockResolvedValueOnce(mockResponse(cursorPage([run]))); + + const result = await getRunsByOrder('nts', '100'); + + expect(result).toHaveLength(1); + const url = new URL(mockFetch.mock.calls[0][0]); + expect(url.searchParams.get('order')).toBe('100'); + }); +}); + +describe('getRecentRuns', () => { + it('fetches a single page of runs with sort', async () => { + mockFetch.mockResolvedValueOnce(mockResponse(cursorPage<RunInfo>([], null))); + + await getRecentRuns('nts', { limit: 50, sort: '-start_time' }); + + const url = new URL(mockFetch.mock.calls[0][0]); + expect(url.searchParams.get('limit')).toBe('50'); + expect(url.searchParams.get('sort')).toBe('-start_time'); + }); +}); + +describe('getFieldChanges', () => { + it('fetches field changes with limit', async () => { + const fc: FieldChangeInfo = { + uuid: 'fc1', test: 't1', machine: 'm1', metric: 'compile_time', + old_value: 1.0, new_value: 2.0, start_order: '99', end_order: '100', + run_uuid: null, + }; + mockFetch.mockResolvedValueOnce(mockResponse(cursorPage([fc]))); + + const result = await getFieldChanges('nts', { limit: 1 }); + + expect(result.items).toHaveLength(1); + const url = new URL(mockFetch.mock.calls[0][0]); + expect(url.pathname).toBe('/api/v5/nts/field-changes'); + expect(url.searchParams.get('limit')).toBe('1'); + }); +}); + +describe('searchOrdersByTag', () => { + it('passes tag_prefix and limit params', async () => { + const order: OrderSummary = { fields: { rev: '100' }, tag: 'release-18' }; + mockFetch.mockResolvedValueOnce(mockResponse(cursorPage([order]))); + + const result = await searchOrdersByTag('nts', 'release', { limit: 10 }); + + expect(result.items).toHaveLength(1); + expect(result.items[0].tag).toBe('release-18'); + const url = new URL(mockFetch.mock.calls[0][0]); + expect(url.pathname).toBe('/api/v5/nts/orders'); + expect(url.searchParams.get('tag_prefix')).toBe('release'); + expect(url.searchParams.get('limit')).toBe('10'); + }); +}); + +describe('updateOrderTag', () => { + it('sends PATCH with tag in JSON body', async () => { + const order: OrderDetail = { + fields: { rev: '100' }, tag: 'new-tag', + previous_order: null, next_order: null, + }; + mockFetch.mockResolvedValueOnce(mockResponse(order)); + + const result = await updateOrderTag('nts', '100', 'new-tag'); + + expect(result.tag).toBe('new-tag'); + const [url, opts] = mockFetch.mock.calls[0]; + expect(new URL(url).pathname).toBe('/api/v5/nts/orders/100'); + expect(opts.method).toBe('PATCH'); + expect(JSON.parse(opts.body)).toEqual({ tag: 'new-tag' }); + expect(opts.headers['Content-Type']).toBe('application/json'); + }); + + it('includes auth token when set', async () => { + storedToken = 'my-admin-token'; + mockFetch.mockResolvedValueOnce(mockResponse({ + fields: { rev: '100' }, tag: null, previous_order: null, next_order: null, + })); + + await updateOrderTag('nts', '100', null); + + const [, opts] = mockFetch.mock.calls[0]; + expect(opts.headers['Authorization']).toBe('Bearer my-admin-token'); + }); + + it('throws on non-ok response', async () => { + mockFetch.mockResolvedValueOnce(mockResponse('Forbidden', 403, 'Forbidden')); + + await expect(updateOrderTag('nts', '100', 'x')).rejects.toThrow('API 403'); + }); +}); + +describe('queryDataPoints', () => { + it('passes machine and metric as query params', async () => { + const pt: QueryDataPoint = { + test: 't1', machine: 'm1', metric: 'exec_time', value: 1.0, + order: { rev: '100' }, run_uuid: 'r1', timestamp: null, + }; + mockFetch.mockResolvedValueOnce(mockResponse(cursorPage([pt]))); + + const result = await queryDataPoints('nts', { machine: 'm1', metric: 'exec_time' }); + + expect(result).toHaveLength(1); + const url = new URL(mockFetch.mock.calls[0][0]); + expect(url.pathname).toBe('/api/v5/nts/query'); + expect(url.searchParams.get('machine')).toBe('m1'); + expect(url.searchParams.get('metric')).toBe('exec_time'); + }); + + it('passes optional filter params', async () => { + mockFetch.mockResolvedValueOnce(mockResponse(cursorPage([]))); + + await queryDataPoints('nts', { + machine: 'm1', metric: 'exec_time', + test: 't1', afterOrder: '100', beforeOrder: '200', + }); + + const url = new URL(mockFetch.mock.calls[0][0]); + expect(url.searchParams.get('test')).toBe('t1'); + expect(url.searchParams.get('after_order')).toBe('100'); + expect(url.searchParams.get('before_order')).toBe('200'); + }); + + it('auto-paginates across multiple pages', async () => { + mockFetch.mockResolvedValueOnce(mockResponse(cursorPage( + [{ test: 't1', machine: 'm1', metric: 'exec_time', value: 1.0, order: { rev: '100' }, run_uuid: 'r1', timestamp: null }], + 'cursor-2', + ))); + mockFetch.mockResolvedValueOnce(mockResponse(cursorPage( + [{ test: 't1', machine: 'm1', metric: 'exec_time', value: 2.0, order: { rev: '101' }, run_uuid: 'r2', timestamp: null }], + ))); + + const result = await queryDataPoints('nts', { machine: 'm1', metric: 'exec_time' }); + + expect(result).toHaveLength(2); + expect(mockFetch).toHaveBeenCalledTimes(2); + }); +}); + +// =========================================================================== +// apiUrl +// =========================================================================== + +describe('apiUrl', () => { + it('constructs URL with encoded test suite name', () => { + setApiBase(''); + expect(apiUrl('nts', 'query')).toBe('/api/v5/nts/query'); + }); + + it('includes apiBase prefix', () => { + setApiBase('/lnt'); + expect(apiUrl('nts', 'machines')).toBe('/lnt/api/v5/nts/machines'); + }); + + it('encodes special characters in test suite name', () => { + setApiBase(''); + expect(apiUrl('my suite', 'orders')).toBe('/api/v5/my%20suite/orders'); + }); +}); + +// =========================================================================== +// fetchOneCursorPage +// =========================================================================== + +describe('fetchOneCursorPage', () => { + it('returns items and nextCursor from a single page', async () => { + const pt: QueryDataPoint = { + test: 't1', machine: 'm1', metric: 'exec_time', value: 1.0, + order: { rev: '100' }, run_uuid: 'r1', timestamp: null, + }; + mockFetch.mockResolvedValueOnce(mockResponse(cursorPage([pt], 'next-abc'))); + + const result = await fetchOneCursorPage<QueryDataPoint>( + '/api/v5/nts/query', { machine: 'm1', limit: '10000' }, + ); + + expect(result.items).toEqual([pt]); + expect(result.nextCursor).toBe('next-abc'); + }); + + it('returns null nextCursor on last page', async () => { + mockFetch.mockResolvedValueOnce(mockResponse(cursorPage([{ test: 't1' }], null))); + + const result = await fetchOneCursorPage('/api/v5/nts/query', {}); + + expect(result.nextCursor).toBeNull(); + }); + + it('passes signal to fetch', async () => { + const controller = new AbortController(); + mockFetch.mockResolvedValueOnce(mockResponse(cursorPage([]))); + + await fetchOneCursorPage('/api/v5/nts/query', {}, controller.signal); + + expect(mockFetch.mock.calls[0][1].signal).toBe(controller.signal); + }); + + it('passes limit and cursor as query params', async () => { + mockFetch.mockResolvedValueOnce(mockResponse(cursorPage([]))); + + await fetchOneCursorPage('/api/v5/nts/query', { + machine: 'm1', metric: 'exec_time', sort: '-order', limit: '10000', cursor: 'abc', + }); + + const url = new URL(mockFetch.mock.calls[0][0]); + expect(url.searchParams.get('machine')).toBe('m1'); + expect(url.searchParams.get('metric')).toBe('exec_time'); + expect(url.searchParams.get('sort')).toBe('-order'); + expect(url.searchParams.get('limit')).toBe('10000'); + expect(url.searchParams.get('cursor')).toBe('abc'); + }); +}); diff --git a/lnt/server/ui/v5/frontend/src/__tests__/chart.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/chart.test.ts new file mode 100644 index 000000000..02a139449 --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/__tests__/chart.test.ts @@ -0,0 +1,227 @@ +import { describe, it, expect } from 'vitest'; +import { prepareChartData } from '../chart'; +import type { ComparisonRow } from '../types'; + +/** Helper to build a ComparisonRow with sensible defaults. */ +function makeRow(overrides: Partial<ComparisonRow> & { test: string }): ComparisonRow { + return { + valueA: 100, + valueB: 110, + delta: 10, + deltaPct: 10, + ratio: 1.1, + status: 'improved', + sidePresent: 'both', + ...overrides, + }; +} + +describe('prepareChartData', () => { + it('filters out rows where sidePresent !== "both"', () => { + const rows: ComparisonRow[] = [ + makeRow({ test: 'a-only', sidePresent: 'a_only', ratio: 1.1 }), + makeRow({ test: 'b-only', sidePresent: 'b_only', ratio: 1.2 }), + makeRow({ test: 'both-ok', sidePresent: 'both', ratio: 1.05 }), + ]; + const result = prepareChartData(rows, null); + expect(result).not.toBeNull(); + expect(result!.sortedTests).toEqual(['both-ok']); + }); + + it('filters out rows where ratio is null', () => { + const rows: ComparisonRow[] = [ + makeRow({ test: 'no-ratio', ratio: null }), + makeRow({ test: 'has-ratio', ratio: 1.05 }), + ]; + const result = prepareChartData(rows, null); + expect(result).not.toBeNull(); + expect(result!.sortedTests).toEqual(['has-ratio']); + }); + + it('filters out rows where status is "na"', () => { + const rows: ComparisonRow[] = [ + makeRow({ test: 'na-status', status: 'na', ratio: 1.1 }), + makeRow({ test: 'ok-status', status: 'improved', ratio: 1.05 }), + ]; + const result = prepareChartData(rows, null); + expect(result).not.toBeNull(); + expect(result!.sortedTests).toEqual(['ok-status']); + }); + + it('includes noise rows (visibility is controlled by the caller)', () => { + const rows: ComparisonRow[] = [ + makeRow({ test: 'noisy', status: 'noise', ratio: 1.001 }), + makeRow({ test: 'improved', status: 'improved', ratio: 1.2 }), + ]; + const result = prepareChartData(rows, null); + expect(result).not.toBeNull(); + expect(result!.sortedTests).toContain('noisy'); + expect(result!.sortedTests).toHaveLength(2); + }); + + it('filterTests filters to specific test names', () => { + const rows: ComparisonRow[] = [ + makeRow({ test: 'alpha', ratio: 1.1 }), + makeRow({ test: 'beta', ratio: 1.2 }), + makeRow({ test: 'gamma', ratio: 0.9 }), + ]; + const filter = new Set(['alpha', 'gamma']); + const result = prepareChartData(rows, filter); + expect(result).not.toBeNull(); + expect(result!.sortedTests).toHaveLength(2); + expect(result!.sortedTests).toContain('alpha'); + expect(result!.sortedTests).toContain('gamma'); + expect(result!.sortedTests).not.toContain('beta'); + }); + + it('sorts by ratio ascending', () => { + const rows: ComparisonRow[] = [ + makeRow({ test: 'high', ratio: 1.5, status: 'improved' }), + makeRow({ test: 'low', ratio: 0.5, status: 'regressed' }), + makeRow({ test: 'mid', ratio: 1.0, status: 'noise' }), + ]; + const result = prepareChartData(rows, null); + expect(result).not.toBeNull(); + expect(result!.sortedTests).toEqual(['low', 'mid', 'high']); + }); + + it('returns null when no plottable data', () => { + // All rows filtered out: a_only, null ratio, na status + const rows: ComparisonRow[] = [ + makeRow({ test: 'a-only', sidePresent: 'a_only' }), + makeRow({ test: 'no-ratio', ratio: null }), + makeRow({ test: 'na', status: 'na' }), + ]; + expect(prepareChartData(rows, null)).toBeNull(); + + // Empty input + expect(prepareChartData([], null)).toBeNull(); + }); + + it('assigns correct colors by status', () => { + const rows: ComparisonRow[] = [ + makeRow({ test: 'imp', status: 'improved', ratio: 1.1 }), + makeRow({ test: 'reg', status: 'regressed', ratio: 0.9 }), + makeRow({ test: 'noi', status: 'noise', ratio: 1.001 }), + makeRow({ test: 'unc', status: 'unchanged', ratio: 1.0 }), + ]; + const result = prepareChartData(rows, null); + expect(result).not.toBeNull(); + + // Map test names to colors for order-independent assertions + const colorByTest = new Map( + result!.sortedTests.map((t, i) => [t, result!.colors[i]]) + ); + expect(colorByTest.get('imp')).toBe('#2ca02c'); // improved = green + expect(colorByTest.get('reg')).toBe('#d62728'); // regressed = red + expect(colorByTest.get('noi')).toBe('#999999'); // noise = grey + expect(colorByTest.get('unc')).toBe('#1f77b4'); // unchanged/other = blue + }); + + it('computes y values as (ratio - 1) * 100', () => { + const rows: ComparisonRow[] = [ + makeRow({ test: 'a', ratio: 1.2, status: 'improved' }), + makeRow({ test: 'b', ratio: 0.8, status: 'regressed' }), + makeRow({ test: 'c', ratio: 1.0, status: 'noise' }), + ]; + const result = prepareChartData(rows, null); + expect(result).not.toBeNull(); + + // Map test names to y values for order-independent assertions + const yByTest = new Map( + result!.sortedTests.map((t, i) => [t, result!.y[i]]) + ); + expect(yByTest.get('a')).toBeCloseTo(20); // (1.2 - 1) * 100 + expect(yByTest.get('b')).toBeCloseTo(-20); // (0.8 - 1) * 100 + expect(yByTest.get('c')).toBeCloseTo(0); // (1.0 - 1) * 100 + }); + + it('produces correct customdata format', () => { + const rows: ComparisonRow[] = [ + makeRow({ + test: 'mytest', + valueA: 100, + valueB: 120, + deltaPct: 20, + ratio: 1.2, + status: 'improved', + }), + ]; + const result = prepareChartData(rows, null); + expect(result).not.toBeNull(); + expect(result!.customdata).toHaveLength(1); + + const cd = result!.customdata[0]; + expect(cd[0]).toBe('mytest'); // test name + expect(cd[1]).toBe((100).toPrecision(4)); // valueA + expect(cd[2]).toBe((120).toPrecision(4)); // valueB + expect(cd[3]).toBe('+20.00%'); // deltaPct with sign + expect(cd[4]).toBe((1.2).toFixed(4)); // ratio + }); + + it('customdata handles null values', () => { + const rows: ComparisonRow[] = [ + makeRow({ + test: 'partial', + valueA: null, + valueB: null, + deltaPct: null, + ratio: 1.05, + status: 'noise', + }), + ]; + const result = prepareChartData(rows, null); + expect(result).not.toBeNull(); + + const cd = result!.customdata[0]; + expect(cd[0]).toBe('partial'); + expect(cd[1]).toBe('N/A'); + expect(cd[2]).toBe('N/A'); + expect(cd[3]).toBe('N/A'); + expect(cd[4]).toBe((1.05).toFixed(4)); + }); + + it('customdata formats negative deltaPct without explicit plus sign', () => { + const rows: ComparisonRow[] = [ + makeRow({ + test: 'regtest', + valueA: 100, + valueB: 80, + deltaPct: -20, + ratio: 0.8, + status: 'regressed', + }), + ]; + const result = prepareChartData(rows, null); + expect(result).not.toBeNull(); + + const cd = result!.customdata[0]; + expect(cd[3]).toBe('-20.00%'); + }); + + it('x values are sequential indices starting at 0', () => { + const rows: ComparisonRow[] = [ + makeRow({ test: 'a', ratio: 1.1 }), + makeRow({ test: 'b', ratio: 1.2 }), + makeRow({ test: 'c', ratio: 0.9 }), + ]; + const result = prepareChartData(rows, null); + expect(result).not.toBeNull(); + expect(result!.x).toEqual([0, 1, 2]); + }); + + it('filterTests combined with noise rows', () => { + const rows: ComparisonRow[] = [ + makeRow({ test: 'keep', status: 'improved', ratio: 1.2 }), + makeRow({ test: 'noise-keep', status: 'noise', ratio: 1.001 }), + makeRow({ test: 'filter-out', status: 'improved', ratio: 1.1 }), + ]; + const filter = new Set(['keep', 'noise-keep']); + const result = prepareChartData(rows, filter); + expect(result).not.toBeNull(); + // noise-keep is included (caller handles visibility), filter-out is excluded + expect(result!.sortedTests).toHaveLength(2); + expect(result!.sortedTests).toContain('keep'); + expect(result!.sortedTests).toContain('noise-keep'); + }); +}); diff --git a/lnt/server/ui/v5/frontend/src/__tests__/combobox.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/combobox.test.ts new file mode 100644 index 000000000..cb047686c --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/__tests__/combobox.test.ts @@ -0,0 +1,182 @@ +// @vitest-environment jsdom +import { describe, it, expect, vi, beforeEach } from 'vitest'; +import type { SideSelection } from '../types'; + +// Mock the API module +vi.mock('../api', () => ({ + getMachines: vi.fn().mockResolvedValue({ items: [] }), + getRuns: vi.fn().mockResolvedValue([]), +})); + +import { createOrderCombobox, resetComboboxState, type ComboboxContext } from '../combobox'; + +function makeContext(overrides?: Partial<ComboboxContext>): ComboboxContext { + const sideA: SideSelection = { order: '', machine: '', runs: [], runAgg: 'median' }; + return { + cachedOrderValues: ['100', '101', '102'], + orderTags: new Map([['100', 'release-1'], ['101', null], ['102', 'release-2']]), + testsuite: 'nts', + getSideState: () => ({ + selection: sideA, + setSide: (partial: Partial<SideSelection>) => Object.assign(sideA, partial), + label: 'Side A', + }), + ...overrides, + }; +} + +describe('createOrderCombobox', () => { + beforeEach(() => { + vi.clearAllMocks(); + resetComboboxState(); + }); + + it('shows tags in dropdown items', () => { + const ctx = makeContext(); + const wrapper = createOrderCombobox('a', () => {}, () => {}, ctx); + document.body.append(wrapper); + + const input = wrapper.querySelector('input')!; + input.dispatchEvent(new Event('focus')); + + const items = wrapper.querySelectorAll('.combobox-item'); + const texts = Array.from(items).map(li => li.textContent); + expect(texts).toContain('100 (release-1)'); + expect(texts).toContain('101'); + expect(texts).toContain('102 (release-2)'); + + wrapper.remove(); + }); + + it('filters by tag text', () => { + const ctx = makeContext(); + const wrapper = createOrderCombobox('a', () => {}, () => {}, ctx); + document.body.append(wrapper); + + const input = wrapper.querySelector('input')! as HTMLInputElement; + input.value = 'release-2'; + input.dispatchEvent(new Event('input')); + + const items = wrapper.querySelectorAll('.combobox-item'); + expect(items).toHaveLength(1); + expect(items[0].textContent).toBe('102 (release-2)'); + + wrapper.remove(); + }); + + it('filters by order value', () => { + const ctx = makeContext(); + const wrapper = createOrderCombobox('a', () => {}, () => {}, ctx); + document.body.append(wrapper); + + const input = wrapper.querySelector('input')! as HTMLInputElement; + input.value = '101'; + input.dispatchEvent(new Event('input')); + + const items = wrapper.querySelectorAll('.combobox-item'); + expect(items).toHaveLength(1); + expect(items[0].textContent).toBe('101'); + + wrapper.remove(); + }); + + it('shows loading hint when machine is set but orders not loaded', () => { + const sideA: SideSelection = { order: '', machine: 'clang-x86', runs: [], runAgg: 'median' }; + const ctx = makeContext({ + getSideState: () => ({ + selection: sideA, + setSide: (partial: Partial<SideSelection>) => Object.assign(sideA, partial), + label: 'Side A', + }), + }); + // machineOrdersA is null (not loaded) — resetComboboxState ensures this + const wrapper = createOrderCombobox('a', () => {}, () => {}, ctx); + document.body.append(wrapper); + + const input = wrapper.querySelector('input')!; + input.dispatchEvent(new Event('focus')); + + const items = wrapper.querySelectorAll('.combobox-item'); + expect(items).toHaveLength(1); + expect(items[0].textContent).toBe('Loading orders...'); + + wrapper.remove(); + }); + + it('calls setSide with order value (not tag) on selection', () => { + const sideA: SideSelection = { order: '', machine: '', runs: [], runAgg: 'median' }; + const setSide = vi.fn(); + const ctx = makeContext({ + getSideState: () => ({ + selection: sideA, + setSide, + label: 'Side A', + }), + }); + const wrapper = createOrderCombobox('a', setSide, () => {}, ctx); + document.body.append(wrapper); + + const input = wrapper.querySelector('input')!; + input.dispatchEvent(new Event('focus')); + + const items = wrapper.querySelectorAll('.combobox-item'); + // Click the tagged item "100 (release-1)" + (items[0] as HTMLElement).click(); + + expect(setSide).toHaveBeenCalledWith({ order: '100' }); + + wrapper.remove(); + }); + + it('shows tag in input after selection', () => { + const ctx = makeContext(); + const wrapper = createOrderCombobox('a', () => {}, () => {}, ctx); + document.body.append(wrapper); + + const input = wrapper.querySelector('input')! as HTMLInputElement; + input.dispatchEvent(new Event('focus')); + + const items = wrapper.querySelectorAll('.combobox-item'); + (items[0] as HTMLElement).click(); + + expect(input.value).toBe('100 (release-1)'); + + wrapper.remove(); + }); + + it('shows tag in input on URL restore', () => { + const sideA: SideSelection = { order: '102', machine: '', runs: [], runAgg: 'median' }; + const ctx = makeContext({ + getSideState: () => ({ + selection: sideA, + setSide: () => {}, + label: 'Side A', + }), + }); + const wrapper = createOrderCombobox('a', () => {}, () => {}, ctx); + document.body.append(wrapper); + + const input = wrapper.querySelector('input')! as HTMLInputElement; + expect(input.value).toBe('102 (release-2)'); + + wrapper.remove(); + }); + + it('shows plain value when order has no tag', () => { + const sideA: SideSelection = { order: '101', machine: '', runs: [], runAgg: 'median' }; + const ctx = makeContext({ + getSideState: () => ({ + selection: sideA, + setSide: () => {}, + label: 'Side A', + }), + }); + const wrapper = createOrderCombobox('a', () => {}, () => {}, ctx); + document.body.append(wrapper); + + const input = wrapper.querySelector('input')! as HTMLInputElement; + expect(input.value).toBe('101'); + + wrapper.remove(); + }); +}); diff --git a/lnt/server/ui/v5/frontend/src/__tests__/comparison.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/comparison.test.ts new file mode 100644 index 000000000..e6128505b --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/__tests__/comparison.test.ts @@ -0,0 +1,567 @@ +import { describe, it, expect } from 'vitest'; +import { + aggregateSamplesWithinRun, + aggregateAcrossRuns, + computeComparison, + computeGeomean, +} from '../comparison'; +import type { SampleInfo, ComparisonRow } from '../types'; + +describe('aggregateSamplesWithinRun', () => { + it('groups by test name and applies median', () => { + const samples: SampleInfo[] = [ + { test: 'foo', has_profile: false, metrics: { exec_time: 10 } }, + { test: 'foo', has_profile: false, metrics: { exec_time: 20 } }, + { test: 'foo', has_profile: false, metrics: { exec_time: 30 } }, + { test: 'bar', has_profile: false, metrics: { exec_time: 5 } }, + ]; + const result = aggregateSamplesWithinRun(samples, 'exec_time', 'median'); + expect(result.get('foo')).toBe(20); + expect(result.get('bar')).toBe(5); + }); + + it('skips null metric values', () => { + const samples: SampleInfo[] = [ + { test: 'foo', has_profile: false, metrics: { exec_time: 10 } }, + { test: 'foo', has_profile: false, metrics: { exec_time: null } }, + { test: 'foo', has_profile: false, metrics: { exec_time: 30 } }, + ]; + const result = aggregateSamplesWithinRun(samples, 'exec_time', 'mean'); + expect(result.get('foo')).toBe(20); // mean(10, 30) = 20 + }); + + it('skips samples missing the metric entirely', () => { + const samples: SampleInfo[] = [ + { test: 'foo', has_profile: false, metrics: { other_metric: 10 } }, + ]; + const result = aggregateSamplesWithinRun(samples, 'exec_time', 'median'); + expect(result.size).toBe(0); + }); + + it('returns empty map for empty samples', () => { + const result = aggregateSamplesWithinRun([], 'exec_time', 'median'); + expect(result.size).toBe(0); + }); + + it('uses the specified aggregation function', () => { + const samples: SampleInfo[] = [ + { test: 'foo', has_profile: false, metrics: { exec_time: 10 } }, + { test: 'foo', has_profile: false, metrics: { exec_time: 20 } }, + { test: 'foo', has_profile: false, metrics: { exec_time: 30 } }, + ]; + expect(aggregateSamplesWithinRun(samples, 'exec_time', 'min').get('foo')).toBe(10); + expect(aggregateSamplesWithinRun(samples, 'exec_time', 'max').get('foo')).toBe(30); + expect(aggregateSamplesWithinRun(samples, 'exec_time', 'mean').get('foo')).toBe(20); + }); +}); + +describe('aggregateAcrossRuns', () => { + it('returns empty map for empty array', () => { + expect(aggregateAcrossRuns([], 'median').size).toBe(0); + }); + + it('returns the single map directly', () => { + const m = new Map([['foo', 10], ['bar', 20]]); + const result = aggregateAcrossRuns([m], 'median'); + expect(result).toEqual(m); + }); + + it('aggregates across multiple maps with overlapping tests', () => { + const m1 = new Map([['foo', 10], ['bar', 20]]); + const m2 = new Map([['foo', 30], ['bar', 40]]); + const result = aggregateAcrossRuns([m1, m2], 'mean'); + expect(result.get('foo')).toBe(20); // mean(10, 30) + expect(result.get('bar')).toBe(30); // mean(20, 40) + }); + + it('handles disjoint tests across maps', () => { + const m1 = new Map([['foo', 10]]); + const m2 = new Map([['bar', 20]]); + const result = aggregateAcrossRuns([m1, m2], 'median'); + expect(result.get('foo')).toBe(10); + expect(result.get('bar')).toBe(20); + }); + + it('handles partial overlap', () => { + const m1 = new Map([['foo', 10], ['bar', 20]]); + const m2 = new Map([['bar', 40], ['baz', 50]]); + const result = aggregateAcrossRuns([m1, m2], 'mean'); + expect(result.get('foo')).toBe(10); // only in m1 + expect(result.get('bar')).toBe(30); // mean(20, 40) + expect(result.get('baz')).toBe(50); // only in m2 + }); +}); + +describe('computeComparison', () => { + it('marks improvement when bigger_is_better=true and B > A', () => { + const mapA = new Map([['foo', 100]]); + const mapB = new Map([['foo', 120]]); + const rows = computeComparison(mapA, mapB, true, 1); + expect(rows).toHaveLength(1); + expect(rows[0].test).toBe('foo'); + expect(rows[0].status).toBe('improved'); + expect(rows[0].delta).toBe(20); + expect(rows[0].deltaPct).toBeCloseTo(20); + expect(rows[0].ratio).toBeCloseTo(1.2); + expect(rows[0].sidePresent).toBe('both'); + }); + + it('marks regression when bigger_is_better=true and B < A', () => { + const mapA = new Map([['foo', 120]]); + const mapB = new Map([['foo', 100]]); + const rows = computeComparison(mapA, mapB, true, 1); + expect(rows[0].test).toBe('foo'); + expect(rows[0].status).toBe('regressed'); + }); + + it('flips direction when bigger_is_better=false', () => { + // Lower is better: B < A means improvement + const mapA = new Map([['foo', 120]]); + const mapB = new Map([['foo', 100]]); + const rows = computeComparison(mapA, mapB, false, 1); + expect(rows[0].test).toBe('foo'); + expect(rows[0].status).toBe('improved'); + + // Lower is better: B > A means regression + const mapA2 = new Map([['foo', 100]]); + const mapB2 = new Map([['foo', 120]]); + const rows2 = computeComparison(mapA2, mapB2, false, 1); + expect(rows2[0].test).toBe('foo'); + expect(rows2[0].status).toBe('regressed'); + }); + + it('marks noise when delta % is within threshold', () => { + const mapA = new Map([['foo', 100]]); + const mapB = new Map([['foo', 100.5]]); // 0.5% change, threshold is 1% + const rows = computeComparison(mapA, mapB, true, 1); + expect(rows[0].test).toBe('foo'); + expect(rows[0].status).toBe('noise'); + }); + + it('handles zero baseline (valueA=0)', () => { + const mapA = new Map([['foo', 0]]); + const mapB = new Map([['foo', 5]]); + const rows = computeComparison(mapA, mapB, true, 1); + expect(rows[0].test).toBe('foo'); + expect(rows[0].status).toBe('na'); + expect(rows[0].delta).toBe(5); + expect(rows[0].deltaPct).toBeNull(); + expect(rows[0].ratio).toBeNull(); + }); + + it('handles both values zero', () => { + const mapA = new Map([['foo', 0]]); + const mapB = new Map([['foo', 0]]); + const rows = computeComparison(mapA, mapB, true, 1); + expect(rows[0].test).toBe('foo'); + expect(rows[0].status).toBe('na'); + expect(rows[0].delta).toBe(0); + expect(rows[0].deltaPct).toBeNull(); + expect(rows[0].ratio).toBeNull(); + }); + + it('handles negative baseline with Math.abs in deltaPct', () => { + const mapA = new Map([['foo', -10]]); + const mapB = new Map([['foo', -5]]); + const rows = computeComparison(mapA, mapB, true, 1); + // delta = -5 - (-10) = 5, deltaPct = 5/10 * 100 = 50% + expect(rows[0].test).toBe('foo'); + expect(rows[0].delta).toBe(5); + expect(rows[0].deltaPct).toBeCloseTo(50); + expect(rows[0].ratio).toBeCloseTo(0.5); // -5 / -10 + expect(rows[0].status).toBe('improved'); // bigger is better, delta > 0 + }); + + it('marks missing when test only in side A', () => { + const mapA = new Map([['foo', 100]]); + const mapB = new Map<string, number>(); + const rows = computeComparison(mapA, mapB, true, 1); + expect(rows[0].test).toBe('foo'); + expect(rows[0].status).toBe('missing'); + expect(rows[0].sidePresent).toBe('a_only'); + expect(rows[0].valueA).toBe(100); + expect(rows[0].valueB).toBeNull(); + }); + + it('marks missing when test only in side B', () => { + const mapA = new Map<string, number>(); + const mapB = new Map([['foo', 100]]); + const rows = computeComparison(mapA, mapB, true, 1); + expect(rows[0].test).toBe('foo'); + expect(rows[0].status).toBe('missing'); + expect(rows[0].sidePresent).toBe('b_only'); + expect(rows[0].valueA).toBeNull(); + expect(rows[0].valueB).toBe(100); + }); + + it('returns empty for empty maps', () => { + const rows = computeComparison(new Map(), new Map(), true, 1); + expect(rows).toHaveLength(0); + }); +}); + +describe('computeComparison — noise boundary edge cases', () => { + it('classifies exactly-at-threshold change as noise (<=)', () => { + // 5% change with noiseThreshold=5 => deltaPct === threshold => noise + const mapA = new Map([['foo', 100]]); + const mapB = new Map([['foo', 105]]); + const rows = computeComparison(mapA, mapB, true, 5); + expect(rows[0].test).toBe('foo'); + expect(rows[0].deltaPct).toBeCloseTo(5); + expect(rows[0].status).toBe('noise'); + }); + + it('classifies exactly-at-threshold negative change as noise', () => { + // -5% change with noiseThreshold=5 => |deltaPct| === threshold => noise + const mapA = new Map([['foo', 100]]); + const mapB = new Map([['foo', 95]]); + const rows = computeComparison(mapA, mapB, true, 5); + expect(rows[0].test).toBe('foo'); + expect(rows[0].deltaPct).toBeCloseTo(-5); + expect(rows[0].status).toBe('noise'); + }); + + it('classifies just-above-threshold change as improved (bigger_is_better=true)', () => { + // 5.01% change with noiseThreshold=5 => exceeds threshold => improved + const mapA = new Map([['foo', 100]]); + const mapB = new Map([['foo', 105.01]]); + const rows = computeComparison(mapA, mapB, true, 5); + expect(rows[0].test).toBe('foo'); + expect(rows[0].deltaPct).toBeGreaterThan(5); + expect(rows[0].status).toBe('improved'); + }); + + it('classifies just-above-threshold negative change as regressed (bigger_is_better=true)', () => { + // -5.01% change with noiseThreshold=5 => exceeds threshold => regressed + const mapA = new Map([['foo', 100]]); + const mapB = new Map([['foo', 94.99]]); + const rows = computeComparison(mapA, mapB, true, 5); + expect(rows[0].test).toBe('foo'); + expect(rows[0].deltaPct).toBeLessThan(-5); + expect(rows[0].status).toBe('regressed'); + }); + + it('classifies just-below-threshold change as noise', () => { + // 4.99% change with noiseThreshold=5 => below threshold => noise + const mapA = new Map([['foo', 100]]); + const mapB = new Map([['foo', 104.99]]); + const rows = computeComparison(mapA, mapB, true, 5); + expect(rows[0].test).toBe('foo'); + expect(rows[0].deltaPct).toBeCloseTo(4.99); + expect(rows[0].status).toBe('noise'); + }); + + it('with noiseThreshold=0, tiny positive change is improved', () => { + // Even 0.001% change should not be noise when threshold is 0 + const mapA = new Map([['foo', 100]]); + const mapB = new Map([['foo', 100.001]]); + const rows = computeComparison(mapA, mapB, true, 0); + expect(rows[0].test).toBe('foo'); + expect(rows[0].deltaPct).toBeGreaterThan(0); + expect(rows[0].status).toBe('improved'); + }); + + it('with noiseThreshold=0, tiny negative change is regressed', () => { + const mapA = new Map([['foo', 100]]); + const mapB = new Map([['foo', 99.999]]); + const rows = computeComparison(mapA, mapB, true, 0); + expect(rows[0].test).toBe('foo'); + expect(rows[0].deltaPct).toBeLessThan(0); + expect(rows[0].status).toBe('regressed'); + }); + + it('with noiseThreshold=0, delta=0 is still noise', () => { + // Identical values => deltaPct=0, and |0| <= 0 is true => noise + const mapA = new Map([['foo', 42]]); + const mapB = new Map([['foo', 42]]); + const rows = computeComparison(mapA, mapB, true, 0); + expect(rows[0].test).toBe('foo'); + expect(rows[0].delta).toBe(0); + expect(rows[0].deltaPct).toBe(0); + expect(rows[0].status).toBe('noise'); + }); + + it('delta=0 is noise regardless of noise threshold', () => { + // With a large threshold, zero delta is obviously noise + const mapA = new Map([['foo', 50]]); + const mapB = new Map([['foo', 50]]); + const rowsLarge = computeComparison(mapA, mapB, true, 10); + expect(rowsLarge[0].test).toBe('foo'); + expect(rowsLarge[0].status).toBe('noise'); + + // With threshold=0, zero delta is still noise + const rowsZero = computeComparison(mapA, mapB, false, 0); + expect(rowsZero[0].test).toBe('foo'); + expect(rowsZero[0].status).toBe('noise'); + + // With a tiny threshold, zero delta is still noise + const rowsTiny = computeComparison(mapA, mapB, true, 0.001); + expect(rowsTiny[0].test).toBe('foo'); + expect(rowsTiny[0].status).toBe('noise'); + }); + + it('with noiseThreshold=0 and bigger_is_better=false, tiny changes are classified correctly', () => { + // Lower is better: B < A => improved + const mapA = new Map([['foo', 100]]); + const mapB = new Map([['foo', 99.999]]); + const rows = computeComparison(mapA, mapB, false, 0); + expect(rows[0].test).toBe('foo'); + expect(rows[0].status).toBe('improved'); + + // Lower is better: B > A => regressed + const mapA2 = new Map([['foo', 100]]); + const mapB2 = new Map([['foo', 100.001]]); + const rows2 = computeComparison(mapA2, mapB2, false, 0); + expect(rows2[0].test).toBe('foo'); + expect(rows2[0].status).toBe('regressed'); + }); +}); + +describe('computeComparison — multi-test mixed status', () => { + it('produces all status types in a single call and returns correct fields per row', () => { + // bigger_is_better=true, noiseThreshold=5% + // + // improved: test-improved A=100, B=120 => delta=20, deltaPct=20%, ratio=1.2 + // regressed: test-regressed A=100, B=70 => delta=-30, deltaPct=-30%, ratio=0.7 + // noise: test-noise A=100, B=103 => delta=3, deltaPct=3% (within 5%) + // a_only: test-a-only A=200, B=absent + // b_only: test-b-only A=absent, B=300 + + const mapA = new Map<string, number>([ + ['test-improved', 100], + ['test-regressed', 100], + ['test-noise', 100], + ['test-a-only', 200], + ]); + + const mapB = new Map<string, number>([ + ['test-improved', 120], + ['test-regressed', 70], + ['test-noise', 103], + ['test-b-only', 300], + ]); + + const rows = computeComparison(mapA, mapB, true, 5); + expect(rows).toHaveLength(5); + + // Index into rows by test name for order-independent assertions + const byTest = new Map(rows.map(r => [r.test, r])); + + // improved + const improved = byTest.get('test-improved')!; + expect(improved.test).toBe('test-improved'); + expect(improved.status).toBe('improved'); + expect(improved.valueA).toBe(100); + expect(improved.valueB).toBe(120); + expect(improved.delta).toBe(20); + expect(improved.deltaPct).toBeCloseTo(20); + expect(improved.ratio).toBeCloseTo(1.2); + expect(improved.sidePresent).toBe('both'); + + // regressed + const regressed = byTest.get('test-regressed')!; + expect(regressed.test).toBe('test-regressed'); + expect(regressed.status).toBe('regressed'); + expect(regressed.valueA).toBe(100); + expect(regressed.valueB).toBe(70); + expect(regressed.delta).toBe(-30); + expect(regressed.deltaPct).toBeCloseTo(-30); + expect(regressed.ratio).toBeCloseTo(0.7); + expect(regressed.sidePresent).toBe('both'); + + // noise (within threshold) + const noise = byTest.get('test-noise')!; + expect(noise.test).toBe('test-noise'); + expect(noise.status).toBe('noise'); + expect(noise.valueA).toBe(100); + expect(noise.valueB).toBe(103); + expect(noise.delta).toBe(3); + expect(noise.deltaPct).toBeCloseTo(3); + expect(noise.ratio).toBeCloseTo(1.03); + expect(noise.sidePresent).toBe('both'); + + // a_only (missing from side B) + const aOnly = byTest.get('test-a-only')!; + expect(aOnly.test).toBe('test-a-only'); + expect(aOnly.status).toBe('missing'); + expect(aOnly.valueA).toBe(200); + expect(aOnly.valueB).toBeNull(); + expect(aOnly.delta).toBeNull(); + expect(aOnly.deltaPct).toBeNull(); + expect(aOnly.ratio).toBeNull(); + expect(aOnly.sidePresent).toBe('a_only'); + + // b_only (missing from side A) + const bOnly = byTest.get('test-b-only')!; + expect(bOnly.test).toBe('test-b-only'); + expect(bOnly.status).toBe('missing'); + expect(bOnly.valueA).toBeNull(); + expect(bOnly.valueB).toBe(300); + expect(bOnly.delta).toBeNull(); + expect(bOnly.deltaPct).toBeNull(); + expect(bOnly.ratio).toBeNull(); + expect(bOnly.sidePresent).toBe('b_only'); + }); +}); + +describe('computeGeomean', () => { + function makeRow(overrides: Partial<ComparisonRow>): ComparisonRow { + return { + test: 'test', + valueA: 100, + valueB: 120, + delta: 20, + deltaPct: 20, + ratio: 1.2, + status: 'improved', + sidePresent: 'both', + ...overrides, + }; + } + + it('returns null for empty rows', () => { + expect(computeGeomean([])).toBeNull(); + }); + + it('returns null when all rows are missing', () => { + const rows = [ + makeRow({ sidePresent: 'a_only', ratio: null, valueB: null, status: 'missing' }), + makeRow({ sidePresent: 'b_only', ratio: null, valueA: null, status: 'missing' }), + ]; + expect(computeGeomean(rows)).toBeNull(); + }); + + it('returns null when all rows are na', () => { + const rows = [makeRow({ status: 'na', ratio: 1.5 })]; + expect(computeGeomean(rows)).toBeNull(); + }); + + it('computes correct ratio geomean for known values', () => { + // geomean of ratios [2, 8] = sqrt(16) = 4 + const rows = [ + makeRow({ valueA: 50, valueB: 100, ratio: 2 }), + makeRow({ valueA: 10, valueB: 80, ratio: 8 }), + ]; + const result = computeGeomean(rows)!; + expect(result).not.toBeNull(); + expect(result.ratioGeomean).toBeCloseTo(4); + }); + + it('computes geomeanA and geomeanB from absolute values', () => { + // geomean([100, 400]) = sqrt(40000) = 200 + // geomean([200, 800]) = sqrt(160000) = 400 + const rows = [ + makeRow({ valueA: 100, valueB: 200, ratio: 2 }), + makeRow({ valueA: 400, valueB: 800, ratio: 2 }), + ]; + const result = computeGeomean(rows)!; + expect(result.geomeanA).toBeCloseTo(200); + expect(result.geomeanB).toBeCloseTo(400); + expect(result.delta).toBeCloseTo(200); + expect(result.deltaPct).toBeCloseTo(100); // 200/200 * 100 + }); + + it('ignores rows with null ratio', () => { + const rows = [ + makeRow({ valueA: 50, valueB: 100, ratio: 2 }), + makeRow({ ratio: null, status: 'improved' }), + makeRow({ valueA: 10, valueB: 80, ratio: 8 }), + ]; + const result = computeGeomean(rows)!; + expect(result.ratioGeomean).toBeCloseTo(4); + }); + + it('ignores a_only and b_only rows', () => { + const rows = [ + makeRow({ valueA: 50, valueB: 100, ratio: 2 }), + makeRow({ sidePresent: 'a_only', ratio: null, valueB: null, status: 'missing' }), + makeRow({ valueA: 10, valueB: 80, ratio: 8 }), + ]; + const result = computeGeomean(rows)!; + expect(result.ratioGeomean).toBeCloseTo(4); + }); + + it('single row: geomean equals the values', () => { + const rows = [makeRow({ valueA: 100, valueB: 150, ratio: 1.5 })]; + const result = computeGeomean(rows)!; + expect(result.geomeanA).toBeCloseTo(100); + expect(result.geomeanB).toBeCloseTo(150); + expect(result.ratioGeomean).toBeCloseTo(1.5); + }); + + it('all ratios = 1.0: ratio geomean = 1.0', () => { + const rows = [ + makeRow({ valueA: 100, valueB: 100, ratio: 1.0, status: 'noise' }), + makeRow({ valueA: 200, valueB: 200, ratio: 1.0, status: 'noise' }), + makeRow({ valueA: 50, valueB: 50, ratio: 1.0, status: 'noise' }), + ]; + const result = computeGeomean(rows)!; + expect(result.ratioGeomean).toBeCloseTo(1.0); + expect(result.delta).toBeCloseTo(0); + }); + + it('returns null when valueA is zero (status=na is filtered out)', () => { + // In real data, valueA=0 produces status='na', which is excluded + const rows = [makeRow({ valueA: 0, valueB: 10, ratio: null, status: 'na' })]; + expect(computeGeomean(rows)).toBeNull(); + }); + + it('produces valid geomean for negative values', () => { + // Both sides negative: geomean of absolute values + // |valueA| = [10, 40], geomean = sqrt(400) = 20 + // |valueB| = [20, 80], geomean = sqrt(1600) = 40 + const rows = [ + makeRow({ valueA: -10, valueB: -20, ratio: 2, status: 'improved' }), + makeRow({ valueA: -40, valueB: -80, ratio: 2, status: 'improved' }), + ]; + const result = computeGeomean(rows)!; + expect(result).not.toBeNull(); + expect(result.geomeanA).toBeCloseTo(20); + expect(result.geomeanB).toBeCloseTo(40); + expect(result.ratioGeomean).toBeCloseTo(2); + expect(Number.isNaN(result.geomeanA)).toBe(false); + expect(Number.isNaN(result.geomeanB)).toBe(false); + }); + + it('excludes rows with zero values', () => { + // Row with valueB=0 should be excluded; only the non-zero row contributes + const rows = [ + makeRow({ valueA: 100, valueB: 200, ratio: 2, status: 'improved' }), + makeRow({ valueA: 50, valueB: 0, ratio: 0, status: 'improved' }), + ]; + const result = computeGeomean(rows)!; + expect(result).not.toBeNull(); + expect(result.geomeanA).toBeCloseTo(100); + expect(result.geomeanB).toBeCloseTo(200); + expect(result.ratioGeomean).toBeCloseTo(2); + expect(Number.isFinite(result.geomeanA)).toBe(true); + expect(Number.isFinite(result.geomeanB)).toBe(true); + }); + + it('returns null when all rows have zero values', () => { + const rows = [ + makeRow({ valueA: 0, valueB: 0, ratio: null, status: 'na' }), + makeRow({ valueA: 0, valueB: 5, ratio: null, status: 'na' }), + ]; + expect(computeGeomean(rows)).toBeNull(); + }); + + it('handles mixed positive and negative values correctly', () => { + // Mix of positive and negative: geomean uses absolute values + // |valueA| = [100, 50], geomean = sqrt(5000) ≈ 70.71 + // |valueB| = [200, 25], geomean = sqrt(5000) ≈ 70.71 + const rows = [ + makeRow({ valueA: 100, valueB: 200, ratio: 2, status: 'improved' }), + makeRow({ valueA: -50, valueB: -25, ratio: 0.5, status: 'regressed' }), + ]; + const result = computeGeomean(rows)!; + expect(result).not.toBeNull(); + expect(Number.isNaN(result.geomeanA)).toBe(false); + expect(Number.isNaN(result.geomeanB)).toBe(false); + expect(Number.isFinite(result.geomeanA)).toBe(true); + expect(Number.isFinite(result.geomeanB)).toBe(true); + expect(result.geomeanA).toBeCloseTo(Math.sqrt(100 * 50)); + expect(result.geomeanB).toBeCloseTo(Math.sqrt(200 * 25)); + expect(result.ratioGeomean).toBeCloseTo(1); // geomean([2, 0.5]) = sqrt(1) = 1 + }); +}); diff --git a/lnt/server/ui/v5/frontend/src/__tests__/data-table.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/data-table.test.ts new file mode 100644 index 000000000..2a60a0a9b --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/__tests__/data-table.test.ts @@ -0,0 +1,159 @@ +// @vitest-environment jsdom +import { describe, it, expect } from 'vitest'; +import { renderDataTable } from '../components/data-table'; +import type { Column } from '../components/data-table'; + +interface TestRow { + name: string; + value: number; +} + +const columns: Column<TestRow>[] = [ + { key: 'name', label: 'Name' }, + { key: 'value', label: 'Value', cellClass: 'col-num', + sortValue: (r) => r.value }, +]; + +const rows: TestRow[] = [ + { name: 'alpha', value: 3 }, + { name: 'beta', value: 1 }, + { name: 'gamma', value: 2 }, +]; + +describe('renderDataTable', () => { + it('renders a table with header and rows', () => { + const container = document.createElement('div'); + renderDataTable(container, { columns, rows }); + + const table = container.querySelector('table'); + expect(table).not.toBeNull(); + + const ths = table!.querySelectorAll('th'); + expect(ths).toHaveLength(2); + expect(ths[0].textContent).toContain('Name'); + expect(ths[1].textContent).toContain('Value'); + + const trs = table!.querySelectorAll('tbody tr'); + expect(trs).toHaveLength(3); + }); + + it('shows empty message when no rows', () => { + const container = document.createElement('div'); + renderDataTable(container, { + columns, + rows: [], + emptyMessage: 'Nothing here.', + }); + + const td = container.querySelector('td.no-results'); + expect(td).not.toBeNull(); + expect(td!.textContent).toBe('Nothing here.'); + }); + + it('sorts by column when header clicked', () => { + const container = document.createElement('div'); + renderDataTable(container, { columns, rows, sortKey: 'value', sortDir: 'asc' }); + + // Initial sort: value ascending → beta(1), gamma(2), alpha(3) + let cells = container.querySelectorAll('tbody tr td:first-child'); + expect(cells[0].textContent).toBe('beta'); + expect(cells[2].textContent).toBe('alpha'); + + // Click Value header to toggle to descending + const valueHeader = container.querySelectorAll('th')[1]; + valueHeader.click(); + + cells = container.querySelectorAll('tbody tr td:first-child'); + expect(cells[0].textContent).toBe('alpha'); + expect(cells[2].textContent).toBe('beta'); + }); + + it('applies cellClass to data cells', () => { + const container = document.createElement('div'); + renderDataTable(container, { columns, rows: rows.slice(0, 1) }); + + const valueTd = container.querySelector('tbody tr td:nth-child(2)'); + expect(valueTd!.className).toBe('col-num'); + }); + + it('calls onRowClick when a row is clicked', () => { + const clicked: TestRow[] = []; + const container = document.createElement('div'); + renderDataTable(container, { + columns, rows: rows.slice(0, 1), + onRowClick: (row) => clicked.push(row), + }); + + const tr = container.querySelector('tbody tr') as HTMLElement; + tr.click(); + expect(clicked).toHaveLength(1); + expect(clicked[0].name).toBe('alpha'); + }); + + it('renders custom Node from render callback', () => { + const container = document.createElement('div'); + const cols: Column<TestRow>[] = [ + { key: 'name', label: 'Name', + render: (r) => { + const span = document.createElement('span'); + span.className = 'custom'; + span.textContent = r.name.toUpperCase(); + return span; + } }, + ]; + renderDataTable(container, { columns: cols, rows: rows.slice(0, 1) }); + + const span = container.querySelector('tbody td span.custom'); + expect(span).not.toBeNull(); + expect(span!.textContent).toBe('ALPHA'); + }); + + it('does not add sortable class or click handler when sortable is false', () => { + const container = document.createElement('div'); + const cols: Column<TestRow>[] = [ + { key: 'name', label: 'Name', sortable: false }, + { key: 'value', label: 'Value', sortValue: (r) => r.value }, + ]; + renderDataTable(container, { columns: cols, rows, sortKey: 'value', sortDir: 'asc' }); + + const nameHeader = container.querySelectorAll('th')[0]; + expect(nameHeader.classList.contains('sortable')).toBe(false); + + // Click the non-sortable header — sort order should not change + const cellsBefore = container.querySelectorAll('tbody tr td:first-child'); + const firstBefore = cellsBefore[0].textContent; + nameHeader.click(); + const cellsAfter = container.querySelectorAll('tbody tr td:first-child'); + expect(cellsAfter[0].textContent).toBe(firstBefore); + }); + + it('applies rowClass to each row', () => { + const container = document.createElement('div'); + renderDataTable(container, { + columns, rows: rows.slice(0, 2), + rowClass: (r) => r.value > 2 ? 'highlight' : '', + }); + + const trs = container.querySelectorAll('tbody tr'); + expect(trs[0].className).toBe('highlight'); // alpha, value=3 + expect(trs[1].className).toBe(''); // beta, value=1 + }); + + it('resets sort direction to asc when clicking a different column', () => { + const container = document.createElement('div'); + renderDataTable(container, { columns, rows, sortKey: 'value', sortDir: 'desc' }); + + // Currently sorted by value desc: alpha(3), gamma(2), beta(1) + let cells = container.querySelectorAll('tbody tr td:first-child'); + expect(cells[0].textContent).toBe('alpha'); + + // Click Name header — should sort by name ascending + const nameHeader = container.querySelectorAll('th')[0]; + nameHeader.click(); + + cells = container.querySelectorAll('tbody tr td:first-child'); + expect(cells[0].textContent).toBe('alpha'); + expect(cells[1].textContent).toBe('beta'); + expect(cells[2].textContent).toBe('gamma'); + }); +}); diff --git a/lnt/server/ui/v5/frontend/src/__tests__/legend-table.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/legend-table.test.ts new file mode 100644 index 000000000..d8ded15b8 --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/__tests__/legend-table.test.ts @@ -0,0 +1,167 @@ +// @vitest-environment jsdom +import { describe, it, expect, vi, afterEach, beforeEach } from 'vitest'; +import { createLegendTable, type LegendEntry } from '../components/legend-table'; +import { GRAPH_TABLE_HOVER } from '../events'; + +// jsdom doesn't provide CSS.escape — polyfill for tests +if (typeof CSS === 'undefined' || !CSS.escape) { + (globalThis as Record<string, unknown>).CSS = { + escape: (s: string) => s.replace(/([^\w-])/g, '\\$1'), + }; +} + +function makeEntries(active: string[], inactive: string[]): LegendEntry[] { + return [ + ...active.map((name, i) => ({ testName: name, color: `#color${i}`, active: true })), + ...inactive.map((name, i) => ({ testName: name, color: `#gray${i}`, active: false })), + ]; +} + +const noop = vi.fn(); + +describe('createLegendTable', () => { + beforeEach(() => { + vi.useFakeTimers(); + }); + + afterEach(() => { + vi.useRealTimers(); + document.body.replaceChildren(); + }); + + it('renders rows in entry order with inactive rows grayed out', () => { + const container = document.createElement('div'); + const entries: LegendEntry[] = [ + { testName: 'alpha', color: '#c0', active: true }, + { testName: 'beta', color: '#c1', active: false }, + { testName: 'gamma', color: '#c2', active: true }, + ]; + createLegendTable(container, { entries, onToggle: noop, onIsolate: noop }); + + const rows = container.querySelectorAll('tr'); + expect(rows).toHaveLength(3); + expect(rows[0].getAttribute('data-test')).toBe('alpha'); + expect(rows[0].classList.contains('legend-row-inactive')).toBe(false); + expect(rows[1].getAttribute('data-test')).toBe('beta'); + expect(rows[1].classList.contains('legend-row-inactive')).toBe(true); + expect(rows[2].getAttribute('data-test')).toBe('gamma'); + expect(rows[2].classList.contains('legend-row-inactive')).toBe(false); + }); + + it('shows colored symbol with correct color', () => { + const container = document.createElement('div'); + const entries: LegendEntry[] = [ + { testName: 'test-A', color: '#ff0000', active: true }, + ]; + createLegendTable(container, { entries, onToggle: noop, onIsolate: noop }); + + const symbol = container.querySelector('.legend-symbol') as HTMLElement; + expect(symbol).not.toBeNull(); + expect(symbol.style.color).toBe('rgb(255, 0, 0)'); + expect(symbol.textContent).toBe('●'); // default symbol when none specified + }); + + it('calls onToggle when a row is single-clicked (after delay)', () => { + const container = document.createElement('div'); + const onToggle = vi.fn(); + createLegendTable(container, { entries: makeEntries(['test-A'], []), onToggle, onIsolate: noop }); + + const row = container.querySelector('tr[data-test="test-A"]') as HTMLElement; + row.click(); + + // Not called yet (delayed to distinguish from double-click) + expect(onToggle).not.toHaveBeenCalled(); + + vi.advanceTimersByTime(200); + expect(onToggle).toHaveBeenCalledWith('test-A'); + }); + + it('calls onIsolate on double-click without triggering onToggle', () => { + const container = document.createElement('div'); + const onToggle = vi.fn(); + const onIsolate = vi.fn(); + createLegendTable(container, { entries: makeEntries(['test-A'], []), onToggle, onIsolate }); + + const row = container.querySelector('tr[data-test="test-A"]') as HTMLElement; + // Simulate double-click: two clicks then dblclick + row.click(); + row.click(); + row.dispatchEvent(new MouseEvent('dblclick', { bubbles: true })); + + vi.advanceTimersByTime(200); + + expect(onIsolate).toHaveBeenCalledWith('test-A'); + expect(onToggle).not.toHaveBeenCalled(); + }); + + it('update() replaces table content', () => { + const container = document.createElement('div'); + const handle = createLegendTable(container, { + entries: makeEntries(['test-A'], []), + onToggle: noop, + onIsolate: noop, + }); + + handle.update(makeEntries(['test-B', 'test-C'], [])); + + const rows = container.querySelectorAll('tr'); + expect(rows).toHaveLength(2); + expect(rows[0].getAttribute('data-test')).toBe('test-B'); + expect(rows[1].getAttribute('data-test')).toBe('test-C'); + }); + + it('highlightRow() adds and removes highlight class', () => { + const container = document.createElement('div'); + const handle = createLegendTable(container, { + entries: makeEntries(['test-A', 'test-B'], []), + onToggle: noop, + onIsolate: noop, + }); + + handle.highlightRow('test-A'); + const rowA = container.querySelector('tr[data-test="test-A"]')!; + expect(rowA.classList.contains('row-highlighted')).toBe(true); + + handle.highlightRow('test-B'); + expect(rowA.classList.contains('row-highlighted')).toBe(false); + const rowB = container.querySelector('tr[data-test="test-B"]')!; + expect(rowB.classList.contains('row-highlighted')).toBe(true); + + handle.highlightRow(null); + expect(rowB.classList.contains('row-highlighted')).toBe(false); + }); + + it('dispatches GRAPH_TABLE_HOVER on mouseenter/mouseleave', () => { + const container = document.createElement('div'); + document.body.append(container); + createLegendTable(container, { + entries: makeEntries(['test-A'], []), + onToggle: noop, + onIsolate: noop, + }); + + const events: Array<string | null> = []; + document.addEventListener(GRAPH_TABLE_HOVER, ((e: CustomEvent) => { + events.push(e.detail); + }) as EventListener); + + const row = container.querySelector('tr[data-test="test-A"]') as HTMLElement; + row.dispatchEvent(new MouseEvent('mouseenter', { bubbles: true })); + row.dispatchEvent(new MouseEvent('mouseleave', { bubbles: true })); + + expect(events).toEqual(['test-A', null]); + }); + + it('destroy() removes the table', () => { + const container = document.createElement('div'); + const handle = createLegendTable(container, { + entries: makeEntries(['test-A'], []), + onToggle: noop, + onIsolate: noop, + }); + + expect(container.querySelector('.legend-table')).not.toBeNull(); + handle.destroy(); + expect(container.querySelector('.legend-table')).toBeNull(); + }); +}); diff --git a/lnt/server/ui/v5/frontend/src/__tests__/machine-combobox.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/machine-combobox.test.ts new file mode 100644 index 000000000..50d0eab2a --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/__tests__/machine-combobox.test.ts @@ -0,0 +1,125 @@ +// @vitest-environment jsdom +import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; + +vi.mock('../api', () => ({ + getMachines: vi.fn(), +})); + +import { renderMachineCombobox } from '../components/machine-combobox'; +import { getMachines } from '../api'; + +const mockGetMachines = getMachines as ReturnType<typeof vi.fn>; + +beforeEach(() => { + vi.useFakeTimers(); + mockGetMachines.mockReset(); + document.body.innerHTML = ''; +}); + +afterEach(() => { + vi.useRealTimers(); + vi.restoreAllMocks(); +}); + +describe('renderMachineCombobox', () => { + it('renders an input into the container', () => { + const container = document.createElement('div'); + renderMachineCombobox(container, { testsuite: 'nts', onSelect: vi.fn() }); + expect(container.querySelector('input.combobox-input')).not.toBeNull(); + }); + + it('sets initial value on the input', () => { + const container = document.createElement('div'); + renderMachineCombobox(container, { testsuite: 'nts', initialValue: 'clang-x86', onSelect: vi.fn() }); + const input = container.querySelector('input') as HTMLInputElement; + expect(input.value).toBe('clang-x86'); + }); + + it('calls getMachines with namePrefix after debounce', async () => { + mockGetMachines.mockResolvedValue({ items: [], total: 0 }); + const container = document.createElement('div'); + document.body.append(container); + renderMachineCombobox(container, { testsuite: 'nts', onSelect: vi.fn() }); + + const input = container.querySelector('input') as HTMLInputElement; + input.value = 'clang'; + input.dispatchEvent(new Event('input')); + + expect(mockGetMachines).not.toHaveBeenCalled(); + await vi.advanceTimersByTimeAsync(300); + expect(mockGetMachines).toHaveBeenCalledWith('nts', { namePrefix: 'clang', limit: 20 }, expect.anything()); + }); + + it('shows dropdown with results and calls onSelect on click', async () => { + mockGetMachines.mockResolvedValue({ + items: [{ name: 'clang-x86', info: {} }, { name: 'clang-arm', info: {} }], + total: 2, + }); + const onSelect = vi.fn(); + const container = document.createElement('div'); + document.body.append(container); + renderMachineCombobox(container, { testsuite: 'nts', onSelect }); + + const input = container.querySelector('input') as HTMLInputElement; + input.value = 'clang'; + input.dispatchEvent(new Event('input')); + await vi.advanceTimersByTimeAsync(300); + + const items = container.querySelectorAll('li.combobox-item'); + expect(items).toHaveLength(2); + expect(items[0].textContent).toBe('clang-x86'); + + (items[0] as HTMLElement).click(); + expect(onSelect).toHaveBeenCalledWith('clang-x86'); + expect(input.value).toBe('clang-x86'); + }); + + it('calls onSelect with typed value on Enter', () => { + const onSelect = vi.fn(); + const container = document.createElement('div'); + document.body.append(container); + renderMachineCombobox(container, { testsuite: 'nts', onSelect }); + + const input = container.querySelector('input') as HTMLInputElement; + input.value = 'my-machine'; + input.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter' })); + expect(onSelect).toHaveBeenCalledWith('my-machine'); + }); + + it('closes dropdown on Escape', async () => { + mockGetMachines.mockResolvedValue({ + items: [{ name: 'clang-x86', info: {} }], + total: 1, + }); + const container = document.createElement('div'); + document.body.append(container); + renderMachineCombobox(container, { testsuite: 'nts', onSelect: vi.fn() }); + + const input = container.querySelector('input') as HTMLInputElement; + input.value = 'clang'; + input.dispatchEvent(new Event('input')); + await vi.advanceTimersByTimeAsync(300); + + const dropdown = container.querySelector('ul') as HTMLElement; + expect(dropdown.classList.contains('open')).toBe(true); + + input.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape' })); + expect(dropdown.classList.contains('open')).toBe(false); + }); + + it('getValue returns the selected value', () => { + const container = document.createElement('div'); + const handle = renderMachineCombobox(container, { + testsuite: 'nts', initialValue: 'test-machine', onSelect: vi.fn(), + }); + expect(handle.getValue()).toBe('test-machine'); + }); + + it('destroy removes document click listener', () => { + const container = document.createElement('div'); + const handle = renderMachineCombobox(container, { testsuite: 'nts', onSelect: vi.fn() }); + const spy = vi.spyOn(document, 'removeEventListener'); + handle.destroy(); + expect(spy).toHaveBeenCalledWith('click', expect.any(Function)); + }); +}); diff --git a/lnt/server/ui/v5/frontend/src/__tests__/metric-selector.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/metric-selector.test.ts new file mode 100644 index 000000000..7e8d966e4 --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/__tests__/metric-selector.test.ts @@ -0,0 +1,117 @@ +// @vitest-environment jsdom +import { describe, it, expect, vi } from 'vitest'; +import { renderMetricSelector, filterMetricFields } from '../components/metric-selector'; +import type { FieldInfo } from '../types'; + +function makeField(name: string, type = 'Real', displayName: string | null = null): FieldInfo { + return { name, type, display_name: displayName, unit: null, unit_abbrev: null, bigger_is_better: null }; +} + +describe('filterMetricFields', () => { + it('returns only Real-typed fields', () => { + const fields = [ + makeField('status', 'Status'), + makeField('compile_time', 'Real'), + makeField('exec_time', 'Real'), + ]; + const result = filterMetricFields(fields); + expect(result).toHaveLength(2); + expect(result.map(f => f.name)).toEqual(['compile_time', 'exec_time']); + }); + + it('returns empty array when no Real fields', () => { + const result = filterMetricFields([makeField('status', 'Status')]); + expect(result).toHaveLength(0); + }); +}); + +describe('renderMetricSelector', () => { + it('returns empty string and renders nothing when fields array is empty', () => { + const container = document.createElement('div'); + const result = renderMetricSelector(container, [], vi.fn()); + + expect(result).toBe(''); + expect(container.querySelector('select')).toBeNull(); + }); + + it('renders all fields passed to it', () => { + const container = document.createElement('div'); + renderMetricSelector(container, [ + makeField('compile_time', 'Real'), + makeField('exec_time', 'Real'), + ], vi.fn()); + + const options = container.querySelectorAll('option'); + expect(options).toHaveLength(2); + }); + + it('returns the first field name as initial metric', () => { + const container = document.createElement('div'); + const result = renderMetricSelector(container, [ + makeField('compile_time', 'Real'), + makeField('exec_time', 'Real'), + ], vi.fn()); + + expect(result).toBe('compile_time'); + }); + + it('uses display_name when available', () => { + const container = document.createElement('div'); + renderMetricSelector(container, [ + makeField('ct', 'Real', 'Compile Time'), + ], vi.fn()); + + const option = container.querySelector('option'); + expect(option!.textContent).toBe('Compile Time'); + expect(option!.getAttribute('value')).toBe('ct'); + }); + + it('falls back to name when display_name is null', () => { + const container = document.createElement('div'); + renderMetricSelector(container, [ + makeField('exec_time', 'Real'), + ], vi.fn()); + + const option = container.querySelector('option'); + expect(option!.textContent).toBe('exec_time'); + }); + + it('calls onChange with selected metric on change', () => { + const onChange = vi.fn(); + const container = document.createElement('div'); + renderMetricSelector(container, [ + makeField('compile_time', 'Real'), + makeField('exec_time', 'Real'), + ], onChange); + + const select = container.querySelector('select') as HTMLSelectElement; + select.value = 'exec_time'; + select.dispatchEvent(new Event('change')); + + expect(onChange).toHaveBeenCalledWith('exec_time'); + }); + + it('shows placeholder option when placeholder: true', () => { + const container = document.createElement('div'); + const result = renderMetricSelector(container, [ + makeField('compile_time', 'Real'), + makeField('exec_time', 'Real'), + ], vi.fn(), undefined, { placeholder: true }); + + const options = container.querySelectorAll('option'); + expect(options).toHaveLength(3); + expect(options[0].textContent).toBe('-- Select metric --'); + expect(options[0].getAttribute('value')).toBe(''); + expect(result).toBe(''); + }); + + it('selects initialValue even with placeholder', () => { + const container = document.createElement('div'); + const result = renderMetricSelector(container, [ + makeField('compile_time', 'Real'), + makeField('exec_time', 'Real'), + ], vi.fn(), 'exec_time', { placeholder: true }); + + expect(result).toBe('exec_time'); + }); +}); diff --git a/lnt/server/ui/v5/frontend/src/__tests__/nav.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/nav.test.ts new file mode 100644 index 000000000..d70d766e9 --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/__tests__/nav.test.ts @@ -0,0 +1,151 @@ +// @vitest-environment jsdom +import { describe, it, expect, beforeEach, vi } from 'vitest'; + +// Mock the router's navigate before importing nav +vi.mock('../router', () => ({ + navigate: vi.fn(), +})); + +import { renderNav, updateActiveNavLink } from '../components/nav'; +import { navigate } from '../router'; + +beforeEach(() => { + document.body.innerHTML = ''; + vi.clearAllMocks(); + // Provide localStorage stub + const store: Record<string, string> = {}; + vi.stubGlobal('localStorage', { + getItem: (key: string) => store[key] ?? null, + setItem: (key: string, val: string) => { store[key] = val; }, + removeItem: (key: string) => { delete store[key]; }, + }); +}); + +describe('renderNav', () => { + const config = { + testsuite: 'nts', + testsuites: ['nts', 'compile'], + v4Url: '/db_default/v4/nts/recent_activity', + urlBase: '', + }; + + it('renders all expected navigation links', () => { + const nav = renderNav(config); + const links = nav.querySelectorAll('.v5-nav-link[data-path]'); + const labels = Array.from(links).map(l => l.textContent); + expect(labels).toEqual(['Dashboard', 'Graph', 'Compare', 'Regressions', 'Machines', 'Admin']); + }); + + it('renders the LNT brand', () => { + const nav = renderNav(config); + const brand = nav.querySelector('.v5-nav-brand'); + expect(brand?.textContent).toBe('LNT'); + }); + + it('renders suite selector with correct options', () => { + const nav = renderNav(config); + const select = nav.querySelector('.v5-nav-suite-select') as HTMLSelectElement; + expect(select).toBeTruthy(); + const options = Array.from(select.options); + expect(options.map(o => o.value)).toEqual(['nts', 'compile']); + expect(select.value).toBe('nts'); + }); + + it('renders v4 UI link', () => { + const nav = renderNav(config); + const v4Link = Array.from(nav.querySelectorAll('.v5-nav-link')) + .find(l => l.textContent === 'v4 UI') as HTMLAnchorElement; + expect(v4Link).toBeTruthy(); + expect(v4Link.href).toContain('/db_default/v4/nts/recent_activity'); + }); + + it('clicking a nav link calls navigate()', () => { + const nav = renderNav(config); + document.body.append(nav); + + const machinesLink = Array.from(nav.querySelectorAll('.v5-nav-link[data-path]')) + .find(l => l.textContent === 'Machines') as HTMLAnchorElement; + expect(machinesLink).toBeTruthy(); + + machinesLink.click(); + expect(navigate).toHaveBeenCalledWith('/machines'); + }); + + it('clicking brand calls navigate("/")', () => { + const nav = renderNav(config); + document.body.append(nav); + + const brand = nav.querySelector('.v5-nav-brand') as HTMLAnchorElement; + brand.click(); + expect(navigate).toHaveBeenCalledWith('/'); + }); + + it('renders Settings link', () => { + const nav = renderNav(config); + const settingsLink = Array.from(nav.querySelectorAll('.v5-nav-link')) + .find(l => l.textContent === 'Settings'); + expect(settingsLink).toBeTruthy(); + }); +}); + +describe('updateActiveNavLink', () => { + const config = { + testsuite: 'nts', + testsuites: ['nts'], + v4Url: '#', + urlBase: '', + }; + + it('highlights Dashboard for root path', () => { + const nav = renderNav(config); + document.body.append(nav); + + updateActiveNavLink('/'); + + const dashLink = document.querySelector('[data-path="/"]'); + expect(dashLink?.classList.contains('v5-nav-link-active')).toBe(true); + }); + + it('highlights Machines for /machines path', () => { + const nav = renderNav(config); + document.body.append(nav); + + updateActiveNavLink('/machines'); + + const machinesLink = document.querySelector('[data-path="/machines"]'); + expect(machinesLink?.classList.contains('v5-nav-link-active')).toBe(true); + }); + + it('highlights Machines for /machines/foo sub-path', () => { + const nav = renderNav(config); + document.body.append(nav); + + updateActiveNavLink('/machines/foo'); + + const machinesLink = document.querySelector('[data-path="/machines"]'); + expect(machinesLink?.classList.contains('v5-nav-link-active')).toBe(true); + }); + + it('does not highlight Dashboard for non-root paths', () => { + const nav = renderNav(config); + document.body.append(nav); + + updateActiveNavLink('/machines'); + + const dashLink = document.querySelector('[data-path="/"]'); + expect(dashLink?.classList.contains('v5-nav-link-active')).toBe(false); + }); + + it('clears previous active link when path changes', () => { + const nav = renderNav(config); + document.body.append(nav); + + updateActiveNavLink('/machines'); + updateActiveNavLink('/graph'); + + const machinesLink = document.querySelector('[data-path="/machines"]'); + const graphLink = document.querySelector('[data-path="/graph"]'); + expect(machinesLink?.classList.contains('v5-nav-link-active')).toBe(false); + expect(graphLink?.classList.contains('v5-nav-link-active')).toBe(true); + }); +}); diff --git a/lnt/server/ui/v5/frontend/src/__tests__/order-search.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/order-search.test.ts new file mode 100644 index 000000000..81d265646 --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/__tests__/order-search.test.ts @@ -0,0 +1,206 @@ +// @vitest-environment jsdom +import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; + +// Mock modules before importing the component +vi.mock('../api', () => ({ + searchOrdersByTag: vi.fn(), +})); +vi.mock('../router', () => ({ + navigate: vi.fn(), +})); + +import { renderOrderSearch } from '../components/order-search'; +import { searchOrdersByTag } from '../api'; +import { navigate } from '../router'; + +const mockSearch = searchOrdersByTag as ReturnType<typeof vi.fn>; +const mockNavigate = navigate as ReturnType<typeof vi.fn>; + +beforeEach(() => { + vi.useFakeTimers(); + mockSearch.mockReset(); + mockNavigate.mockReset(); + document.body.innerHTML = ''; +}); + +afterEach(() => { + vi.useRealTimers(); + vi.restoreAllMocks(); +}); + +function cursorPage(items: Array<{ fields: Record<string, string>; tag: string | null }>) { + return { items, cursor: { next: null, previous: null } }; +} + +describe('renderOrderSearch', () => { + it('renders an input and dropdown into the container', () => { + const container = document.createElement('div'); + renderOrderSearch(container, { testsuite: 'nts' }); + + expect(container.querySelector('input.order-search-input')).not.toBeNull(); + expect(container.querySelector('ul.order-search-dropdown')).not.toBeNull(); + }); + + it('calls searchOrdersByTag after debounce on input', async () => { + mockSearch.mockResolvedValue(cursorPage([])); + + const container = document.createElement('div'); + document.body.append(container); + renderOrderSearch(container, { testsuite: 'nts' }); + + const input = container.querySelector('input') as HTMLInputElement; + input.value = 'release'; + input.dispatchEvent(new Event('input')); + + // Before debounce fires + expect(mockSearch).not.toHaveBeenCalled(); + + // After debounce (300ms) + await vi.advanceTimersByTimeAsync(300); + + expect(mockSearch).toHaveBeenCalledWith('nts', 'release', { limit: 10 }, expect.anything()); + }); + + it('shows dropdown with results including tags', async () => { + mockSearch.mockResolvedValue(cursorPage([ + { fields: { rev: 'abc123' }, tag: 'release-18' }, + { fields: { rev: 'def456' }, tag: null }, + ])); + + const container = document.createElement('div'); + document.body.append(container); + renderOrderSearch(container, { testsuite: 'nts' }); + + const input = container.querySelector('input') as HTMLInputElement; + input.value = 'rel'; + input.dispatchEvent(new Event('input')); + await vi.advanceTimersByTimeAsync(300); + + const dropdown = container.querySelector('ul') as HTMLElement; + expect(dropdown.classList.contains('open')).toBe(true); + + const items = dropdown.querySelectorAll('li'); + expect(items).toHaveLength(2); + expect(items[0].textContent).toContain('abc123'); + expect(items[0].textContent).toContain('(release-18)'); + expect(items[1].textContent).toContain('def456'); + }); + + it('navigates on dropdown item click', async () => { + mockSearch.mockResolvedValue(cursorPage([ + { fields: { rev: 'abc123' }, tag: 'release-18' }, + ])); + + const container = document.createElement('div'); + document.body.append(container); + renderOrderSearch(container, { testsuite: 'nts' }); + + const input = container.querySelector('input') as HTMLInputElement; + input.value = 'rel'; + input.dispatchEvent(new Event('input')); + await vi.advanceTimersByTimeAsync(300); + + const item = container.querySelector('li') as HTMLElement; + item.click(); + + expect(mockNavigate).toHaveBeenCalledWith('/orders/abc123'); + expect(input.value).toBe(''); + }); + + it('calls onSelect instead of navigate when provided', async () => { + mockSearch.mockResolvedValue(cursorPage([ + { fields: { rev: 'abc123' }, tag: null }, + ])); + + const onSelect = vi.fn(); + const container = document.createElement('div'); + document.body.append(container); + renderOrderSearch(container, { testsuite: 'nts', onSelect }); + + const input = container.querySelector('input') as HTMLInputElement; + input.value = 'abc'; + input.dispatchEvent(new Event('input')); + await vi.advanceTimersByTimeAsync(300); + + const item = container.querySelector('li') as HTMLElement; + item.click(); + + expect(onSelect).toHaveBeenCalledWith('abc123'); + expect(mockNavigate).not.toHaveBeenCalled(); + }); + + it('navigates to typed value on Enter', () => { + const container = document.createElement('div'); + document.body.append(container); + renderOrderSearch(container, { testsuite: 'nts' }); + + const input = container.querySelector('input') as HTMLInputElement; + input.value = 'exact-hash'; + input.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter' })); + + expect(mockNavigate).toHaveBeenCalledWith('/orders/exact-hash'); + }); + + it('closes dropdown on Escape', async () => { + mockSearch.mockResolvedValue(cursorPage([ + { fields: { rev: 'abc' }, tag: null }, + ])); + + const container = document.createElement('div'); + document.body.append(container); + renderOrderSearch(container, { testsuite: 'nts' }); + + const input = container.querySelector('input') as HTMLInputElement; + input.value = 'abc'; + input.dispatchEvent(new Event('input')); + await vi.advanceTimersByTimeAsync(300); + + const dropdown = container.querySelector('ul') as HTMLElement; + expect(dropdown.classList.contains('open')).toBe(true); + + input.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape' })); + expect(dropdown.classList.contains('open')).toBe(false); + }); + + it('hides dropdown when input is empty', async () => { + const container = document.createElement('div'); + document.body.append(container); + renderOrderSearch(container, { testsuite: 'nts' }); + + const input = container.querySelector('input') as HTMLInputElement; + input.value = ''; + input.dispatchEvent(new Event('input')); + await vi.advanceTimersByTimeAsync(300); + + expect(mockSearch).not.toHaveBeenCalled(); + const dropdown = container.querySelector('ul') as HTMLElement; + expect(dropdown.classList.contains('open')).toBe(false); + }); + + it('hides dropdown when API returns no results', async () => { + mockSearch.mockResolvedValue(cursorPage([])); + + const container = document.createElement('div'); + document.body.append(container); + renderOrderSearch(container, { testsuite: 'nts' }); + + const input = container.querySelector('input') as HTMLInputElement; + input.value = 'nothing'; + input.dispatchEvent(new Event('input')); + await vi.advanceTimersByTimeAsync(300); + + const dropdown = container.querySelector('ul') as HTMLElement; + expect(dropdown.classList.contains('open')).toBe(false); + }); + + it('destroy() removes document click listener', () => { + const container = document.createElement('div'); + document.body.append(container); + const handle = renderOrderSearch(container, { testsuite: 'nts' }); + + const spy = vi.spyOn(document, 'removeEventListener'); + handle.destroy(); + + expect(spy).toHaveBeenCalledWith('click', expect.any(Function)); + }); +}); diff --git a/lnt/server/ui/v5/frontend/src/__tests__/pages/admin.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/pages/admin.test.ts new file mode 100644 index 000000000..b4ae0f274 --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/__tests__/pages/admin.test.ts @@ -0,0 +1,262 @@ +// @vitest-environment jsdom +import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; + +// Mock the API module +vi.mock('../../api', async (importOriginal) => { + const actual = await importOriginal<typeof import('../../api')>(); + return { + ...actual, + getApiKeys: vi.fn(), + createApiKey: vi.fn(), + revokeApiKey: vi.fn(), + getTestSuiteInfo: vi.fn(), + createTestSuite: vi.fn(), + deleteTestSuite: vi.fn(), + }; +}); + +// Mock Plotly (may be loaded by transitive imports) +(globalThis as unknown as Record<string, unknown>).Plotly = { + newPlot: vi.fn(), + react: vi.fn(), + purge: vi.fn(), + Fx: { hover: vi.fn(), unhover: vi.fn() }, +}; + +import { getApiKeys, createApiKey, revokeApiKey, getTestSuiteInfo, createTestSuite, deleteTestSuite, ApiError } from '../../api'; +import { adminPage } from '../../pages/admin'; +import type { APIKeyItem, TestSuiteInfo } from '../../types'; + +const mockKeys: APIKeyItem[] = [ + { + prefix: 'abc123', + name: 'Test Key', + scope: 'admin', + created_at: '2026-01-01T00:00:00Z', + last_used_at: null, + is_active: true, + }, + { + prefix: 'def456', + name: 'Revoked Key', + scope: 'read', + created_at: '2025-06-01T00:00:00Z', + last_used_at: '2025-12-01T00:00:00Z', + is_active: false, + }, +]; + +const mockSuiteInfo: TestSuiteInfo = { + name: 'nts', + schema: { + metrics: [ + { name: 'exec_time', type: 'Real', display_name: 'Execution Time', unit: 's', unit_abbrev: 's', bigger_is_better: false }, + ], + order_fields: [{ name: 'rev', type: 'String' }], + machine_fields: [{ name: 'hostname', type: 'String' }], + run_fields: [], + }, +}; + +describe('adminPage', () => { + let container: HTMLElement; + let appRoot: HTMLElement; + + beforeEach(() => { + vi.clearAllMocks(); + container = document.createElement('div'); + + // Set up the #v5-app element with data-testsuites for the admin page to read + appRoot = document.createElement('div'); + appRoot.id = 'v5-app'; + appRoot.setAttribute('data-testsuites', JSON.stringify(['nts', 'test-suite-2'])); + document.body.append(appRoot); + + (getApiKeys as ReturnType<typeof vi.fn>).mockResolvedValue(mockKeys); + (getTestSuiteInfo as ReturnType<typeof vi.fn>).mockResolvedValue(mockSuiteInfo); + (createApiKey as ReturnType<typeof vi.fn>).mockResolvedValue({ + key: 'raw-token-value', + prefix: 'new123', + scope: 'read', + }); + (revokeApiKey as ReturnType<typeof vi.fn>).mockResolvedValue(undefined); + (createTestSuite as ReturnType<typeof vi.fn>).mockResolvedValue(mockSuiteInfo); + (deleteTestSuite as ReturnType<typeof vi.fn>).mockResolvedValue(undefined); + }); + + afterEach(() => { + appRoot.remove(); + }); + + it('renders tab bar with API Keys, Test Suites, and Create Suite tabs', () => { + adminPage.mount(container, { testsuite: '' }); + + const tabs = container.querySelectorAll('.admin-tab'); + expect(tabs).toHaveLength(3); + expect(tabs[0].textContent).toBe('API Keys'); + expect(tabs[1].textContent).toBe('Test Suites'); + expect(tabs[2].textContent).toBe('Create Suite'); + }); + + it('loads and displays API keys table', async () => { + adminPage.mount(container, { testsuite: '' }); + + await vi.waitFor(() => { + expect(getApiKeys).toHaveBeenCalled(); + const rows = container.querySelectorAll('tbody tr'); + expect(rows.length).toBeGreaterThanOrEqual(2); + }); + }); + + it('shows auth error for 401/403', async () => { + (getApiKeys as ReturnType<typeof vi.fn>).mockRejectedValue(new ApiError(403, 'API 403: forbidden')); + + adminPage.mount(container, { testsuite: '' }); + + await vi.waitFor(() => { + const error = container.querySelector('.error-banner'); + expect(error).toBeTruthy(); + expect(error!.textContent).toContain('Permission denied'); + }); + }); + + it('shows create key form', async () => { + adminPage.mount(container, { testsuite: '' }); + + await vi.waitFor(() => { + expect(container.querySelector('.admin-create-form')).toBeTruthy(); + expect(container.querySelector('.admin-input')).toBeTruthy(); + }); + }); + + it('Test Suites tab shows suite selector and loads first suite', async () => { + adminPage.mount(container, { testsuite: '' }); + + await vi.waitFor(() => { + expect(container.querySelector('.admin-create-form')).toBeTruthy(); + }); + + // Click Test Suites tab + const tabs = container.querySelectorAll('.admin-tab'); + (tabs[1] as HTMLElement).click(); + + await vi.waitFor(() => { + // Should have a suite selector with both suites + const select = container.querySelector('.admin-select') as HTMLSelectElement; + expect(select).toBeTruthy(); + expect(select.options).toHaveLength(2); + expect(select.options[0].value).toBe('nts'); + expect(select.options[1].value).toBe('test-suite-2'); + // Should have loaded the first suite + expect(getTestSuiteInfo).toHaveBeenCalledWith('nts', expect.any(AbortSignal)); + expect(container.textContent).toContain('Test Suite: nts'); + }); + }); + + it('Test Suites tab shows metrics and field tables', async () => { + adminPage.mount(container, { testsuite: '' }); + + // Wait for API Keys tab to load first + await vi.waitFor(() => { + expect(container.querySelector('.admin-create-form')).toBeTruthy(); + }); + + // Switch to Test Suites tab + const tabs = container.querySelectorAll('.admin-tab'); + (tabs[1] as HTMLElement).click(); + + await vi.waitFor(() => { + expect(container.textContent).toContain('Metrics'); + expect(container.textContent).toContain('Execution Time'); + expect(container.textContent).toContain('Order Fields'); + expect(container.textContent).toContain('rev'); + expect(container.textContent).toContain('Machine Fields'); + expect(container.textContent).toContain('hostname'); + }); + }); + + it('revoke button only shown for active keys', async () => { + adminPage.mount(container, { testsuite: '' }); + + await vi.waitFor(() => { + const buttons = container.querySelectorAll('.admin-btn-danger'); + expect(buttons).toHaveLength(1); + }); + }); + + it('Create Suite tab shows name input and JSON textarea', async () => { + adminPage.mount(container, { testsuite: '' }); + + await vi.waitFor(() => { + expect(container.querySelectorAll('.admin-tab')).toHaveLength(3); + }); + + const tabs = container.querySelectorAll('.admin-tab'); + (tabs[2] as HTMLElement).click(); + + const inputs = container.querySelectorAll('.admin-input'); + expect(inputs.length).toBeGreaterThanOrEqual(1); + expect(container.querySelector('.admin-textarea')).toBeTruthy(); + }); + + it('Test Suites tab shows delete button with confirmation', async () => { + adminPage.mount(container, { testsuite: '' }); + + await vi.waitFor(() => { + expect(container.querySelector('.admin-create-form')).toBeTruthy(); + }); + + const tabs = container.querySelectorAll('.admin-tab'); + (tabs[1] as HTMLElement).click(); + + await vi.waitFor(() => { + expect(container.querySelector('.admin-delete-section')).toBeTruthy(); + }); + + // Click delete toggle to show confirmation + const deleteToggle = container.querySelector('.admin-delete-section > .admin-btn-danger') as HTMLButtonElement; + deleteToggle.click(); + + // Confirmation panel should be visible with warning and disabled button + const confirmPanel = container.querySelector('.admin-delete-confirm') as HTMLElement; + expect(confirmPanel.style.display).not.toBe('none'); + expect(confirmPanel.textContent).toContain('permanently destroy'); + + const confirmBtn = confirmPanel.querySelector('.admin-btn-danger') as HTMLButtonElement; + expect(confirmBtn).toBeTruthy(); + expect(confirmBtn.disabled).toBe(true); + }); + + it('delete confirm button enables only when name matches', async () => { + adminPage.mount(container, { testsuite: '' }); + + await vi.waitFor(() => { + expect(container.querySelector('.admin-create-form')).toBeTruthy(); + }); + + const tabs = container.querySelectorAll('.admin-tab'); + (tabs[1] as HTMLElement).click(); + + await vi.waitFor(() => { + expect(container.querySelector('.admin-delete-section')).toBeTruthy(); + }); + + // Show confirmation + const deleteToggle = container.querySelector('.admin-delete-section > .admin-btn-danger') as HTMLButtonElement; + deleteToggle.click(); + + const confirmPanel = container.querySelector('.admin-delete-confirm') as HTMLElement; + const confirmInput = confirmPanel.querySelector('.admin-input') as HTMLInputElement; + const confirmBtn = confirmPanel.querySelector('.admin-btn-danger') as HTMLButtonElement; + + // Type wrong name + confirmInput.value = 'wrong'; + confirmInput.dispatchEvent(new Event('input')); + expect(confirmBtn.disabled).toBe(true); + + // Type correct name (first suite = 'nts') + confirmInput.value = 'nts'; + confirmInput.dispatchEvent(new Event('input')); + expect(confirmBtn.disabled).toBe(false); + }); +}); diff --git a/lnt/server/ui/v5/frontend/src/__tests__/pages/compare.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/pages/compare.test.ts new file mode 100644 index 000000000..6c193145e --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/__tests__/pages/compare.test.ts @@ -0,0 +1,101 @@ +// @vitest-environment jsdom +import { describe, it, expect, vi, beforeEach } from 'vitest'; + +// Mock the API module before importing compare page +vi.mock('../../api', () => ({ + getFields: vi.fn(), + getOrders: vi.fn(), + getSamples: vi.fn(), +})); + +// Mock Plotly (loaded via CDN, not available in tests) +const plotlyMock = { + newPlot: vi.fn().mockResolvedValue(document.createElement('div')), + react: vi.fn().mockResolvedValue(document.createElement('div')), + purge: vi.fn(), + Fx: { + hover: vi.fn(), + unhover: vi.fn(), + }, +}; +(globalThis as unknown as Record<string, unknown>).Plotly = plotlyMock; + +import { getFields, getOrders, getSamples } from '../../api'; +import { comparePage } from '../../pages/compare'; +import type { FieldInfo, OrderSummary, SampleInfo } from '../../types'; + +const mockFields: FieldInfo[] = [ + { name: 'exec_time', type: 'Real', display_name: 'Execution Time', unit: 's', unit_abbrev: 's', bigger_is_better: false }, +]; + +const mockOrders: OrderSummary[] = [ + { fields: { rev: '100' }, tag: null }, + { fields: { rev: '101' }, tag: null }, +]; + +const mockSamples: SampleInfo[] = [ + { test: 'test-A', has_profile: false, metrics: { exec_time: 10.0 } }, + { test: 'test-B', has_profile: false, metrics: { exec_time: 20.0 } }, +]; + +function setupMocks(): void { + (getFields as ReturnType<typeof vi.fn>).mockResolvedValue(mockFields); + (getOrders as ReturnType<typeof vi.fn>).mockResolvedValue(mockOrders); + (getSamples as ReturnType<typeof vi.fn>).mockResolvedValue(mockSamples); +} + +describe('comparePage', () => { + let container: HTMLElement; + + beforeEach(() => { + vi.clearAllMocks(); + container = document.createElement('div'); + setupMocks(); + }); + + it('mount loads fields and orders', async () => { + comparePage.mount(container, { testsuite: 'nts' }); + + // Wait for the promise chain to resolve + await vi.waitFor(() => { + expect(getFields).toHaveBeenCalledWith('nts'); + expect(getOrders).toHaveBeenCalledWith('nts'); + }); + }); + + it('shows error when fields/orders fetch fails', async () => { + (getFields as ReturnType<typeof vi.fn>).mockRejectedValue(new Error('Network error')); + + comparePage.mount(container, { testsuite: 'nts' }); + + await vi.waitFor(() => { + expect(container.querySelector('.error-banner')).toBeTruthy(); + }); + }); + + it('renders selection panel after data loads', async () => { + comparePage.mount(container, { testsuite: 'nts' }); + + await vi.waitFor(() => { + // Selection panel should be rendered + expect(container.querySelector('.controls-panel')).toBeTruthy(); + }); + }); + + it('unmount cleans up without errors', async () => { + comparePage.mount(container, { testsuite: 'nts' }); + + await vi.waitFor(() => { + expect(container.querySelector('.controls-panel')).toBeTruthy(); + }); + + // Should not throw + expect(() => comparePage.unmount!()).not.toThrow(); + }); + + it('unmount is safe to call even before mount completes', () => { + comparePage.mount(container, { testsuite: 'nts' }); + // Unmount immediately before async operations complete + expect(() => comparePage.unmount!()).not.toThrow(); + }); +}); diff --git a/lnt/server/ui/v5/frontend/src/__tests__/pages/graph.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/pages/graph.test.ts new file mode 100644 index 000000000..0e9140fc0 --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/__tests__/pages/graph.test.ts @@ -0,0 +1,402 @@ +// @vitest-environment jsdom +import { describe, it, expect } from 'vitest'; +import { buildTraces, computeActiveTests, buildRefsFromCache, setsEqual, TRACE_SEP } from '../../pages/graph'; +import type { QueryDataPoint } from '../../types'; + +function makePoint(test: string, orderValue: string, value: number, runUuid = 'r1'): QueryDataPoint { + return { + test, + machine: 'm1', + metric: 'exec_time', + value, + order: { rev: orderValue }, + run_uuid: runUuid, + timestamp: null, + }; +} + +describe('buildTraces', () => { + it('groups points by test name into separate traces', () => { + const points = [ + makePoint('test-A', '100', 1.0), + makePoint('test-A', '101', 2.0), + makePoint('test-B', '100', 3.0), + ]; + + const traces = buildTraces(points, '', 'median', 'median'); + + expect(traces).toHaveLength(2); + expect(traces[0].testName).toBe('test-A'); + expect(traces[0].points).toHaveLength(2); + expect(traces[1].testName).toBe('test-B'); + expect(traces[1].points).toHaveLength(1); + }); + + it('applies test filter (case-insensitive substring)', () => { + const points = [ + makePoint('compile/test-A', '100', 1.0), + makePoint('exec/test-B', '100', 2.0), + makePoint('compile/test-C', '100', 3.0), + ]; + + const traces = buildTraces(points, 'compile', 'median', 'median'); + + expect(traces).toHaveLength(2); + expect(traces.map(t => t.testName).sort()).toEqual(['compile/test-A', 'compile/test-C']); + }); + + it('aggregates multiple runs at same order using run aggregation', () => { + const points = [ + makePoint('test-A', '100', 1.0, 'r1'), + makePoint('test-A', '100', 3.0, 'r2'), + makePoint('test-A', '100', 5.0, 'r3'), + ]; + + // Median of [1.0, 3.0, 5.0] = 3.0 + const traces = buildTraces(points, '', 'median', 'median'); + expect(traces).toHaveLength(1); + expect(traces[0].points).toHaveLength(1); + expect(traces[0].points[0].value).toBe(3.0); + expect(traces[0].points[0].runCount).toBe(3); + }); + + it('uses mean aggregation when specified', () => { + const points = [ + makePoint('test-A', '100', 1.0, 'r1'), + makePoint('test-A', '100', 3.0, 'r2'), + ]; + + // Mean of [1.0, 3.0] = 2.0 + const traces = buildTraces(points, '', 'mean', 'median'); + expect(traces[0].points[0].value).toBe(2.0); + }); + + it('returns empty array when no points match filter', () => { + const points = [makePoint('test-A', '100', 1.0)]; + + const traces = buildTraces(points, 'nonexistent', 'median', 'median'); + expect(traces).toHaveLength(0); + }); + + it('returns empty array for empty input', () => { + const traces = buildTraces([], '', 'median', 'median'); + expect(traces).toHaveLength(0); + }); + + it('sorts traces by test name', () => { + const points = [ + makePoint('zebra', '100', 1.0), + makePoint('alpha', '100', 2.0), + makePoint('middle', '100', 3.0), + ]; + + const traces = buildTraces(points, '', 'median', 'median'); + expect(traces.map(t => t.testName)).toEqual(['alpha', 'middle', 'zebra']); + }); + + it('preserves order value across aggregation', () => { + const points = [ + makePoint('test-A', '100', 1.0), + makePoint('test-A', '101', 2.0), + makePoint('test-A', '102', 3.0), + ]; + + const traces = buildTraces(points, '', 'median', 'median'); + const orderValues = traces[0].points.map(p => p.orderValue); + expect(orderValues).toEqual(['100', '101', '102']); + }); + + it('preserves insertion order for reversed input (newest-first)', () => { + const points = [ + makePoint('test-A', '102', 3.0), + makePoint('test-A', '101', 2.0), + makePoint('test-A', '100', 1.0), + ]; + + const traces = buildTraces(points, '', 'median', 'median'); + // buildTraces preserves Map insertion order, so reversed input stays reversed + const orderValues = traces[0].points.map(p => p.orderValue); + expect(orderValues).toEqual(['102', '101', '100']); + }); + + it('handles interleaved test data in reverse order', () => { + const points = [ + makePoint('test-A', '102', 3.0), + makePoint('test-B', '102', 6.0), + makePoint('test-A', '101', 2.0), + makePoint('test-B', '101', 5.0), + makePoint('test-A', '100', 1.0), + makePoint('test-B', '100', 4.0), + ]; + + const traces = buildTraces(points, '', 'median', 'median'); + expect(traces).toHaveLength(2); + // test-A comes first alphabetically + expect(traces[0].testName).toBe('test-A'); + expect(traces[0].points.map(p => p.orderValue)).toEqual(['102', '101', '100']); + expect(traces[1].testName).toBe('test-B'); + expect(traces[1].points.map(p => p.orderValue)).toEqual(['102', '101', '100']); + }); +}); + +describe('computeActiveTests', () => { + const names = ['alpha', 'beta', 'charlie', 'delta', 'echo', + 'foxtrot', 'golf', 'hotel', 'india', 'juliet', + 'kilo', 'lima', 'mike', 'november', 'oscar', + 'papa', 'quebec', 'romeo', 'sierra', 'tango', + 'uniform', 'victor', 'whiskey']; + + it('caps at 20 when autoCapped=true and no filter/hidden', () => { + const active = computeActiveTests(names, '', new Set(), true); + expect(active.size).toBe(20); + expect(active.has('alpha')).toBe(true); + expect(active.has('tango')).toBe(true); // 20th + expect(active.has('uniform')).toBe(false); // 21st + }); + + it('disables cap when filter is non-empty', () => { + const active = computeActiveTests(names, 'a', new Set(), true); + // 'alpha', 'charlie', 'delta', 'tango', 'papa', 'sierra', 'whiskey' — all with 'a' + for (const n of names) { + if (n.toLowerCase().includes('a')) { + expect(active.has(n)).toBe(true); + } else { + expect(active.has(n)).toBe(false); + } + } + }); + + it('removes manually hidden tests', () => { + const hidden = new Set(['beta', 'charlie']); + const active = computeActiveTests(names, '', hidden, false); + expect(active.has('alpha')).toBe(true); + expect(active.has('beta')).toBe(false); + expect(active.has('charlie')).toBe(false); + expect(active.has('delta')).toBe(true); + }); + + it('cap is disabled when manuallyHidden is non-empty', () => { + const hidden = new Set(['alpha']); + // autoCapped=true but hidden is non-empty → cap disabled + const active = computeActiveTests(names, '', hidden, true); + // All names except 'alpha' should be active (no 20-cap) + expect(active.size).toBe(names.length - 1); + expect(active.has('alpha')).toBe(false); + expect(active.has('uniform')).toBe(true); // would be capped otherwise + }); + + it('returns empty set for empty input', () => { + const active = computeActiveTests([], '', new Set(), true); + expect(active.size).toBe(0); + }); + + it('double-click isolation is just manuallyHidden with all others hidden', () => { + // Simulates what onIsolate does: hide all except 'charlie' + const hidden = new Set(names.filter(n => n !== 'charlie')); + const active = computeActiveTests(names, '', hidden, false); + expect(active.size).toBe(1); + expect(active.has('charlie')).toBe(true); + }); + + it('after isolation, single-click unhide works naturally', () => { + // After isolating 'charlie', user single-clicks 'alpha' to unhide it + const hidden = new Set(names.filter(n => n !== 'charlie')); + hidden.delete('alpha'); + const active = computeActiveTests(names, '', hidden, false); + expect(active.size).toBe(2); + expect(active.has('charlie')).toBe(true); + expect(active.has('alpha')).toBe(true); + }); + + it('filters multi-machine trace names by test name portion only', () => { + const traceNames = [ + `compile/test-A${TRACE_SEP}clang-x86`, + `compile/test-A${TRACE_SEP}gcc-arm`, + `exec/test-B${TRACE_SEP}clang-x86`, + `exec/test-B${TRACE_SEP}gcc-arm`, + ]; + const active = computeActiveTests(traceNames, 'compile', new Set(), false); + expect(active.size).toBe(2); + expect(active.has(`compile/test-A${TRACE_SEP}clang-x86`)).toBe(true); + expect(active.has(`compile/test-A${TRACE_SEP}gcc-arm`)).toBe(true); + expect(active.has(`exec/test-B${TRACE_SEP}clang-x86`)).toBe(false); + }); + + it('filter does not match machine name', () => { + const traceNames = [ + `test-A${TRACE_SEP}clang-x86`, + `test-A${TRACE_SEP}gcc-arm`, + ]; + const active = computeActiveTests(traceNames, 'clang', new Set(), false); + expect(active.size).toBe(0); + }); +}); + +describe('buildRefsFromCache', () => { + function makeRefPoint(test: string, orderValue: string, value: number, machine = 'm1'): QueryDataPoint { + return { + test, + machine, + metric: 'exec_time', + value, + order: { rev: orderValue }, + run_uuid: 'r1', + timestamp: null, + }; + } + + const median = (values: number[]): number => { + const sorted = [...values].sort((a, b) => a - b); + const mid = Math.floor(sorted.length / 2); + return sorted.length % 2 !== 0 + ? sorted[mid] + : (sorted[mid - 1] + sorted[mid]) / 2; + }; + + const mean = (values: number[]): number => + values.reduce((s, v) => s + v, 0) / values.length; + + it('aggregates multiple runs at pinned order using the provided agg function', () => { + const points = [ + makeRefPoint('test-A', '100', 1.0), + makeRefPoint('test-A', '100', 3.0), + makeRefPoint('test-A', '100', 5.0), + ]; + const refs = [{ value: '100', tag: null }]; + + const result = buildRefsFromCache(points, refs, median); + + expect(result).toHaveLength(1); + expect(result[0].values.get('test-A')).toBe(3.0); // median of [1, 3, 5] + }); + + it('uses the same agg as buildTraces (consistency check)', () => { + const points = [ + makeRefPoint('test-A', '100', 1.0), + makeRefPoint('test-A', '100', 3.0), + makeRefPoint('test-A', '100', 5.0), + ]; + const refs = [{ value: '100', tag: null }]; + + const pinResult = buildRefsFromCache(points, refs, median); + const traces = buildTraces(points, '', 'median', 'median'); + + // Both should produce exactly the same value for test-A at order 100 + const traceValue = traces.find(t => t.testName === 'test-A')!.points + .find(p => p.orderValue === '100')!.value; + expect(pinResult[0].values.get('test-A')).toBe(traceValue); + }); + + it('uses mean aggregation when provided', () => { + const points = [ + makeRefPoint('test-A', '100', 1.0), + makeRefPoint('test-A', '100', 3.0), + ]; + const refs = [{ value: '100', tag: null }]; + + const result = buildRefsFromCache(points, refs, mean); + + expect(result[0].values.get('test-A')).toBe(2.0); // mean of [1, 3] + }); + + it('handles single data point (no aggregation needed)', () => { + const points = [makeRefPoint('test-A', '100', 42.0)]; + const refs = [{ value: '100', tag: null }]; + + const result = buildRefsFromCache(points, refs, median); + + expect(result[0].values.get('test-A')).toBe(42.0); + }); + + it('handles multiple tests at the same pinned order', () => { + const points = [ + makeRefPoint('test-A', '100', 1.0), + makeRefPoint('test-A', '100', 3.0), + makeRefPoint('test-B', '100', 10.0), + makeRefPoint('test-B', '100', 20.0), + ]; + const refs = [{ value: '100', tag: null }]; + + const result = buildRefsFromCache(points, refs, median); + + expect(result[0].values.get('test-A')).toBe(2.0); // median of [1, 3] + expect(result[0].values.get('test-B')).toBe(15.0); // median of [10, 20] + }); + + it('handles multiple pinned orders', () => { + const points = [ + makeRefPoint('test-A', '100', 1.0), + makeRefPoint('test-A', '101', 5.0), + ]; + const refs = [ + { value: '100', tag: 'v1' }, + { value: '101', tag: null }, + ]; + + const result = buildRefsFromCache(points, refs, median); + + expect(result).toHaveLength(2); + expect(result[0].values.get('test-A')).toBe(1.0); + expect(result[0].tag).toBe('v1'); + expect(result[1].values.get('test-A')).toBe(5.0); + expect(result[1].tag).toBeNull(); + }); + + it('returns empty values map when pinned order has no matching data', () => { + const points = [makeRefPoint('test-A', '100', 1.0)]; + const refs = [{ value: '999', tag: null }]; + + const result = buildRefsFromCache(points, refs, median); + + expect(result).toHaveLength(1); + expect(result[0].values.size).toBe(0); + }); + + it('returns empty array when no refs provided', () => { + const points = [makeRefPoint('test-A', '100', 1.0)]; + const result = buildRefsFromCache(points, [], median); + expect(result).toHaveLength(0); + }); + + it('assigns distinct colors from PIN_COLORS to each pinned order', () => { + const points = [ + makeRefPoint('test-A', '100', 1.0), + makeRefPoint('test-A', '101', 2.0), + ]; + const refs = [ + { value: '100', tag: null }, + { value: '101', tag: null }, + ]; + + const result = buildRefsFromCache(points, refs, median); + + expect(result[0].color).not.toBe(result[1].color); + }); +}); + +describe('setsEqual', () => { + it('returns true for two empty sets', () => { + expect(setsEqual(new Set(), new Set())).toBe(true); + }); + + it('returns true for identical sets', () => { + expect(setsEqual(new Set(['a', 'b', 'c']), new Set(['a', 'b', 'c']))).toBe(true); + }); + + it('returns true regardless of insertion order', () => { + expect(setsEqual(new Set(['c', 'a', 'b']), new Set(['b', 'c', 'a']))).toBe(true); + }); + + it('returns false when sizes differ', () => { + expect(setsEqual(new Set(['a', 'b']), new Set(['a', 'b', 'c']))).toBe(false); + }); + + it('returns false when same size but different elements', () => { + expect(setsEqual(new Set(['a', 'b']), new Set(['a', 'c']))).toBe(false); + }); + + it('returns false when one set is empty', () => { + expect(setsEqual(new Set(), new Set(['a']))).toBe(false); + expect(setsEqual(new Set(['a']), new Set())).toBe(false); + }); +}); diff --git a/lnt/server/ui/v5/frontend/src/__tests__/pagination.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/pagination.test.ts new file mode 100644 index 000000000..81ca31a07 --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/__tests__/pagination.test.ts @@ -0,0 +1,92 @@ +// @vitest-environment jsdom +import { describe, it, expect, vi } from 'vitest'; +import { renderPagination } from '../components/pagination'; + +describe('renderPagination', () => { + it('renders Previous and Next buttons', () => { + const container = document.createElement('div'); + renderPagination(container, { + hasPrevious: true, + hasNext: true, + onPrevious: vi.fn(), + onNext: vi.fn(), + }); + + const buttons = container.querySelectorAll('button'); + expect(buttons).toHaveLength(2); + expect(buttons[0].textContent).toContain('Previous'); + expect(buttons[1].textContent).toContain('Next'); + }); + + it('disables Previous when hasPrevious is false', () => { + const container = document.createElement('div'); + renderPagination(container, { + hasPrevious: false, + hasNext: true, + onPrevious: vi.fn(), + onNext: vi.fn(), + }); + + const prevBtn = container.querySelector('button') as HTMLButtonElement; + expect(prevBtn.disabled).toBe(true); + }); + + it('disables Next when hasNext is false', () => { + const container = document.createElement('div'); + renderPagination(container, { + hasPrevious: true, + hasNext: false, + onPrevious: vi.fn(), + onNext: vi.fn(), + }); + + const buttons = container.querySelectorAll('button'); + const nextBtn = buttons[1] as HTMLButtonElement; + expect(nextBtn.disabled).toBe(true); + }); + + it('calls onPrevious when Previous is clicked', () => { + const onPrev = vi.fn(); + const container = document.createElement('div'); + renderPagination(container, { + hasPrevious: true, + hasNext: true, + onPrevious: onPrev, + onNext: vi.fn(), + }); + + const prevBtn = container.querySelector('button') as HTMLButtonElement; + prevBtn.click(); + expect(onPrev).toHaveBeenCalledTimes(1); + }); + + it('calls onNext when Next is clicked', () => { + const onNext = vi.fn(); + const container = document.createElement('div'); + renderPagination(container, { + hasPrevious: true, + hasNext: true, + onPrevious: vi.fn(), + onNext, + }); + + const buttons = container.querySelectorAll('button'); + (buttons[1] as HTMLButtonElement).click(); + expect(onNext).toHaveBeenCalledTimes(1); + }); + + it('displays range text when provided', () => { + const container = document.createElement('div'); + renderPagination(container, { + hasPrevious: false, + hasNext: true, + onPrevious: vi.fn(), + onNext: vi.fn(), + rangeText: '1\u201325 of 100', + }); + + const range = container.querySelector('.pagination-range'); + expect(range).not.toBeNull(); + expect(range!.textContent).toBe('1\u201325 of 100'); + }); +}); diff --git a/lnt/server/ui/v5/frontend/src/__tests__/router.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/router.test.ts new file mode 100644 index 000000000..566b6a8ea --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/__tests__/router.test.ts @@ -0,0 +1,184 @@ +// @vitest-environment jsdom +import { describe, it, expect, beforeEach, vi } from 'vitest'; + +// We need to test the router module. Since it uses global state, +// we import fresh each test by resetting modules. +let routerModule: typeof import('../router'); + +beforeEach(async () => { + // Reset the router's internal state by re-importing + vi.resetModules(); + routerModule = await import('../router'); + + // Reset DOM + document.body.innerHTML = ''; + + // Mock history API + vi.spyOn(window.history, 'pushState').mockImplementation(() => {}); +}); + +describe('addRoute + resolve', () => { + it('matches an exact path and mounts the module', () => { + const container = document.createElement('div'); + const mount = vi.fn(); + const module: import('../router').PageModule = { mount }; + + routerModule.addRoute('/', module); + + // Set window.location to the correct path + Object.defineProperty(window, 'location', { + value: { pathname: '/v5/nts/', search: '', hash: '' }, + writable: true, + }); + + routerModule.initRouter(container, '/v5/nts'); + + expect(mount).toHaveBeenCalledTimes(1); + expect(mount.mock.calls[0][0]).toBe(container); + expect(mount.mock.calls[0][1]).toMatchObject({ testsuite: 'nts' }); + }); + + it('matches parameterized routes', () => { + const container = document.createElement('div'); + const mount = vi.fn(); + const module: import('../router').PageModule = { mount }; + + routerModule.addRoute('/machines/:name', module); + + Object.defineProperty(window, 'location', { + value: { pathname: '/v5/nts/machines/clang-x86', search: '', hash: '' }, + writable: true, + }); + + routerModule.initRouter(container, '/v5/nts'); + + expect(mount).toHaveBeenCalledTimes(1); + expect(mount.mock.calls[0][1]).toMatchObject({ + testsuite: 'nts', + name: 'clang-x86', + }); + }); + + it('decodes URI-encoded parameters', () => { + const container = document.createElement('div'); + const mount = vi.fn(); + const module: import('../router').PageModule = { mount }; + + routerModule.addRoute('/machines/:name', module); + + Object.defineProperty(window, 'location', { + value: { pathname: '/v5/nts/machines/machine%20with%20space', search: '', hash: '' }, + writable: true, + }); + + routerModule.initRouter(container, '/v5/nts'); + + expect(mount.mock.calls[0][1].name).toBe('machine with space'); + }); + + it('shows 404 for unmatched routes', () => { + const container = document.createElement('div'); + + routerModule.addRoute('/', { mount: vi.fn() }); + + Object.defineProperty(window, 'location', { + value: { pathname: '/v5/nts/nonexistent', search: '', hash: '' }, + writable: true, + }); + + routerModule.initRouter(container, '/v5/nts'); + + expect(container.innerHTML).toContain('Page Not Found'); + }); + + it('unmounts previous page before mounting new one', () => { + const container = document.createElement('div'); + const unmount = vi.fn(); + const moduleA: import('../router').PageModule = { mount: vi.fn(), unmount }; + const moduleB: import('../router').PageModule = { mount: vi.fn() }; + + routerModule.addRoute('/', moduleA); + routerModule.addRoute('/other', moduleB); + + Object.defineProperty(window, 'location', { + value: { pathname: '/v5/nts/', search: '', hash: '' }, + writable: true, + }); + + routerModule.initRouter(container, '/v5/nts'); + expect(moduleA.mount).toHaveBeenCalledTimes(1); + + // Navigate to /other + Object.defineProperty(window, 'location', { + value: { pathname: '/v5/nts/other', search: '', hash: '' }, + writable: true, + }); + + routerModule.navigate('/other'); + + expect(unmount).toHaveBeenCalledTimes(1); + expect(moduleB.mount).toHaveBeenCalledTimes(1); + }); + + it('strips trailing slashes for non-root paths', () => { + const container = document.createElement('div'); + const mount = vi.fn(); + routerModule.addRoute('/machines', { mount }); + + Object.defineProperty(window, 'location', { + value: { pathname: '/v5/nts/machines/', search: '', hash: '' }, + writable: true, + }); + + routerModule.initRouter(container, '/v5/nts'); + expect(mount).toHaveBeenCalledTimes(1); + }); +}); + +describe('navigate', () => { + it('calls pushState and resolves the new route', () => { + const container = document.createElement('div'); + const mountA = vi.fn(); + const mountB = vi.fn(); + + routerModule.addRoute('/', { mount: mountA }); + routerModule.addRoute('/machines', { mount: mountB }); + + Object.defineProperty(window, 'location', { + value: { pathname: '/v5/nts/', search: '', hash: '' }, + writable: true, + }); + + routerModule.initRouter(container, '/v5/nts'); + expect(mountA).toHaveBeenCalledTimes(1); + + // Navigate + Object.defineProperty(window, 'location', { + value: { pathname: '/v5/nts/machines', search: '', hash: '' }, + writable: true, + }); + routerModule.navigate('/machines'); + + expect(window.history.pushState).toHaveBeenCalled(); + expect(mountB).toHaveBeenCalledTimes(1); + }); +}); + +describe('afterResolve callback', () => { + it('is called with the resolved route path', () => { + const container = document.createElement('div'); + const callback = vi.fn(); + + routerModule.addRoute('/', { mount: vi.fn() }); + routerModule.addRoute('/machines', { mount: vi.fn() }); + + Object.defineProperty(window, 'location', { + value: { pathname: '/v5/nts/', search: '', hash: '' }, + writable: true, + }); + + routerModule.initRouter(container, '/v5/nts', callback); + + expect(callback).toHaveBeenCalledWith('/'); + }); +}); diff --git a/lnt/server/ui/v5/frontend/src/__tests__/selection.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/selection.test.ts new file mode 100644 index 000000000..3940f7d8f --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/__tests__/selection.test.ts @@ -0,0 +1,69 @@ +// @vitest-environment jsdom +import { describe, it, expect, beforeEach } from 'vitest'; +import { setCachedData, getMetricFields } from '../selection'; +import type { FieldInfo } from '../types'; + +function makeField(overrides: Partial<FieldInfo> & { name: string }): FieldInfo { + return { + type: 'Real', + display_name: null, + unit: null, + unit_abbrev: null, + bigger_is_better: null, + ...overrides, + }; +} + +describe('getMetricFields', () => { + beforeEach(() => { + setCachedData([], [], 'test-suite'); + }); + + it('returns only Real-typed fields', () => { + const fields: FieldInfo[] = [ + makeField({ name: 'exec_time', type: 'Real' }), + makeField({ name: 'score', type: 'Real' }), + makeField({ name: 'hash', type: 'Status' }), + ]; + setCachedData([], fields, 'test-suite'); + + const result = getMetricFields(); + + expect(result).toHaveLength(2); + expect(result.map(f => f.name)).toEqual(['exec_time', 'score']); + }); + + it('excludes Status-typed fields', () => { + const fields: FieldInfo[] = [ + makeField({ name: 'hash', type: 'Status' }), + makeField({ name: 'status_field', type: 'Status' }), + ]; + setCachedData([], fields, 'test-suite'); + + const result = getMetricFields(); + + expect(result).toHaveLength(0); + }); + + it('returns empty array when no fields exist', () => { + setCachedData([], [], 'test-suite'); + + const result = getMetricFields(); + + expect(result).toEqual([]); + }); + + it('preserves field order from input', () => { + const fields: FieldInfo[] = [ + makeField({ name: 'z_metric', type: 'Real' }), + makeField({ name: 'non_metric', type: 'Status' }), + makeField({ name: 'a_metric', type: 'Real' }), + makeField({ name: 'm_metric', type: 'Real' }), + ]; + setCachedData([], fields, 'test-suite'); + + const result = getMetricFields(); + + expect(result.map(f => f.name)).toEqual(['z_metric', 'a_metric', 'm_metric']); + }); +}); diff --git a/lnt/server/ui/v5/frontend/src/__tests__/state.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/state.test.ts new file mode 100644 index 000000000..7f8facc21 --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/__tests__/state.test.ts @@ -0,0 +1,493 @@ +// @vitest-environment jsdom +import { describe, it, expect, beforeEach, vi } from 'vitest'; +import { encodeToUrl, decodeFromUrl, applyUrlState, getState, setState, setSideA, setSideB, swapSides, replaceUrl } from '../state'; +import type { AppState } from '../types'; + +function makeDefaults(): AppState { + return { + sideA: { order: '', machine: '', runs: [], runAgg: 'median' }, + sideB: { order: '', machine: '', runs: [], runAgg: 'median' }, + metric: '', + sampleAgg: 'median', + noise: 1, + sort: 'delta_pct', + sortDir: 'desc', + testFilter: '', + hideNoise: false, + }; +} + +describe('encodeToUrl', () => { + it('returns empty string for all defaults', () => { + expect(encodeToUrl(makeDefaults())).toBe(''); + }); + + it('includes non-default values', () => { + const state = makeDefaults(); + state.sideA.order = 'rev123'; + state.sideA.machine = 'machine-a'; + state.sideA.runs = ['uuid-1']; + state.sideB.order = 'rev456'; + state.sideB.machine = 'machine-b'; + state.sideB.runs = ['uuid-2', 'uuid-3']; + state.sideB.runAgg = 'mean'; + state.metric = 'exec_time'; + state.sampleAgg = 'min'; + state.noise = 2.5; + state.sort = 'ratio'; + state.sortDir = 'asc'; + state.testFilter = 'bench'; + state.hideNoise = true; + + const qs = encodeToUrl(state); + const params = new URLSearchParams(qs); + + expect(params.get('order_a')).toBe('rev123'); + expect(params.get('machine_a')).toBe('machine-a'); + expect(params.get('runs_a')).toBe('uuid-1'); + expect(params.get('order_b')).toBe('rev456'); + expect(params.get('machine_b')).toBe('machine-b'); + expect(params.get('runs_b')).toBe('uuid-2,uuid-3'); + expect(params.get('run_agg_b')).toBe('mean'); + expect(params.get('metric')).toBe('exec_time'); + expect(params.get('sample_agg')).toBe('min'); + expect(params.get('noise')).toBe('2.5'); + expect(params.get('sort')).toBe('ratio'); + expect(params.get('sort_dir')).toBe('asc'); + expect(params.get('test_filter')).toBe('bench'); + expect(params.get('hide_noise')).toBe('1'); + }); + + it('omits default runAgg (median)', () => { + const state = makeDefaults(); + state.sideA.order = 'rev'; + state.sideA.runAgg = 'median'; + const params = new URLSearchParams(encodeToUrl(state)); + expect(params.has('run_agg_a')).toBe(false); + }); + + it('omits noise when it equals default (1)', () => { + const state = makeDefaults(); + state.noise = 1; + state.metric = 'x'; // need something non-default to generate output + const params = new URLSearchParams(encodeToUrl(state)); + expect(params.has('noise')).toBe(false); + }); + + it('includes noise when non-default', () => { + const state = makeDefaults(); + state.noise = 2.5; + const params = new URLSearchParams(encodeToUrl(state)); + expect(params.get('noise')).toBe('2.5'); + }); +}); + +describe('decodeFromUrl', () => { + it('returns empty object for empty query string', () => { + const result = decodeFromUrl(''); + expect(result).toEqual({}); + }); + + it('decodes side A parameters', () => { + const result = decodeFromUrl('?order_a=rev123&machine_a=machine-a&runs_a=uuid-1'); + expect(result.sideA?.order).toBe('rev123'); + expect(result.sideA?.machine).toBe('machine-a'); + expect(result.sideA?.runs).toEqual(['uuid-1']); + }); + + it('decodes multiple run UUIDs', () => { + const result = decodeFromUrl('?runs_b=uuid-1,uuid-2,uuid-3'); + expect(result.sideB?.runs).toEqual(['uuid-1', 'uuid-2', 'uuid-3']); + }); + + it('ignores invalid agg values', () => { + const result = decodeFromUrl('?sample_agg=bogus&run_agg_a=invalid'); + expect(result.sampleAgg).toBeUndefined(); + // sideA should not be set since only run_agg_a was provided with invalid value + // But order_a/machine_a/runs_a are all absent, so runAggA is undefined, + // and nothing triggers sideA creation + expect(result.sideA).toBeUndefined(); + }); + + it('ignores invalid sort values', () => { + const result = decodeFromUrl('?sort=bogus&sort_dir=invalid'); + expect(result.sort).toBeUndefined(); + expect(result.sortDir).toBeUndefined(); + }); + + it('decodes hideNoise=1 as true', () => { + const result = decodeFromUrl('?hide_noise=1'); + expect(result.hideNoise).toBe(true); + }); + + it('decodes hideNoise=0 as false', () => { + const result = decodeFromUrl('?hide_noise=0'); + expect(result.hideNoise).toBe(false); + }); + + it('leaves hideNoise unset when absent', () => { + const result = decodeFromUrl('?metric=exec_time'); + expect(result.hideNoise).toBeUndefined(); + }); + + it('empty runs_a= produces runs: [] (not [""])', () => { + const result = decodeFromUrl('?runs_a='); + expect(result.sideA?.runs ?? []).toEqual([]); + }); + + it('runs_a=,, (commas only) produces runs: []', () => { + const result = decodeFromUrl('?runs_a=,,'); + expect(result.sideA?.runs ?? []).toEqual([]); + }); + + it('runs_a=abc,,def (empty element in middle) produces runs without empty strings', () => { + const result = decodeFromUrl('?runs_a=abc,,def'); + expect(result.sideA?.runs).toEqual(['abc', 'def']); + }); +}); + +describe('round-trip', () => { + it('encode then decode preserves full non-default state', () => { + const state = makeDefaults(); + state.sideA = { order: 'rev1', machine: 'mach-a', runs: ['u1', 'u2'], runAgg: 'mean' }; + state.sideB = { order: 'rev2', machine: 'mach-b', runs: ['u3'], runAgg: 'max' }; + state.metric = 'exec_time'; + state.sampleAgg = 'min'; + state.noise = 3; + state.sort = 'test'; + state.sortDir = 'asc'; + state.testFilter = 'bench'; + state.hideNoise = true; + + const qs = encodeToUrl(state); + const decoded = decodeFromUrl(qs); + + expect(decoded.sideA).toEqual(state.sideA); + expect(decoded.sideB).toEqual(state.sideB); + expect(decoded.metric).toBe(state.metric); + expect(decoded.sampleAgg).toBe(state.sampleAgg); + expect(decoded.noise).toBe(state.noise); + expect(decoded.sort).toBe(state.sort); + expect(decoded.sortDir).toBe(state.sortDir); + expect(decoded.testFilter).toBe(state.testFilter); + expect(decoded.hideNoise).toBe(state.hideNoise); + }); + + it('round-trips multiple run UUIDs', () => { + const state = makeDefaults(); + state.sideA.runs = ['aaa-111', 'bbb-222', 'ccc-333']; + state.sideA.order = 'x'; // needed to trigger sideA encoding + + const qs = encodeToUrl(state); + const decoded = decodeFromUrl(qs); + + expect(decoded.sideA?.runs).toEqual(['aaa-111', 'bbb-222', 'ccc-333']); + }); +}); + +describe('applyUrlState', () => { + beforeEach(() => { + // Reset global state to defaults before each test + applyUrlState(''); + }); + + it('restores state from URL on page load', () => { + applyUrlState('?order_a=rev1&machine_a=mach-a&metric=exec_time&noise=3&sort=ratio&sort_dir=asc'); + const s = getState(); + expect(s.sideA.order).toBe('rev1'); + expect(s.sideA.machine).toBe('mach-a'); + expect(s.metric).toBe('exec_time'); + expect(s.noise).toBe(3); + expect(s.sort).toBe('ratio'); + expect(s.sortDir).toBe('asc'); + }); + + it('resets absent fields to defaults', () => { + // First set some non-default state + setState({ metric: 'exec_time', noise: 5, sort: 'ratio', testFilter: 'bench' }); + expect(getState().metric).toBe('exec_time'); + expect(getState().noise).toBe(5); + + // Now apply a URL that only sets metric — everything else should reset to defaults + applyUrlState('?metric=compile_time'); + const s = getState(); + expect(s.metric).toBe('compile_time'); + expect(s.noise).toBe(1); // default + expect(s.sort).toBe('delta_pct'); // default + expect(s.sortDir).toBe('desc'); // default + expect(s.testFilter).toBe(''); // default + expect(s.hideNoise).toBe(false); // default + expect(s.sideA).toEqual({ order: '', machine: '', runs: [], runAgg: 'median' }); + expect(s.sideB).toEqual({ order: '', machine: '', runs: [], runAgg: 'median' }); + }); + + it('with empty search string sets state to all defaults', () => { + // Set non-default state first + setState({ metric: 'exec_time', noise: 5 }); + setSideA({ order: 'rev1', machine: 'mach-a' }); + + applyUrlState(''); + const s = getState(); + expect(s).toEqual(makeDefaults()); + }); + + it('with partial URL sets only specified fields, unset fields are defaults', () => { + applyUrlState('?order_b=rev2&sample_agg=min&hide_noise=1'); + const s = getState(); + + // Specified fields + expect(s.sideB.order).toBe('rev2'); + expect(s.sampleAgg).toBe('min'); + expect(s.hideNoise).toBe(true); + + // Unset fields should be defaults + expect(s.sideA).toEqual({ order: '', machine: '', runs: [], runAgg: 'median' }); + expect(s.sideB.machine).toBe(''); + expect(s.sideB.runs).toEqual([]); + expect(s.sideB.runAgg).toBe('median'); + expect(s.metric).toBe(''); + expect(s.noise).toBe(1); + expect(s.sort).toBe('delta_pct'); + expect(s.sortDir).toBe('desc'); + expect(s.testFilter).toBe(''); + }); +}); + +describe('getState / setState / setSideA / setSideB', () => { + beforeEach(() => { + applyUrlState(''); + }); + + it('getState returns the current state', () => { + const s = getState(); + expect(s).toEqual(makeDefaults()); + }); + + it('setState merges partial state', () => { + setState({ metric: 'exec_time', noise: 2.5 }); + const s = getState(); + expect(s.metric).toBe('exec_time'); + expect(s.noise).toBe(2.5); + // Other fields unchanged from defaults + expect(s.sort).toBe('delta_pct'); + expect(s.sortDir).toBe('desc'); + expect(s.sampleAgg).toBe('median'); + }); + + it('setSideA merges partial side A selection', () => { + setSideA({ order: 'rev123', machine: 'mach-a' }); + const s = getState(); + expect(s.sideA.order).toBe('rev123'); + expect(s.sideA.machine).toBe('mach-a'); + // Unset fields keep their defaults + expect(s.sideA.runs).toEqual([]); + expect(s.sideA.runAgg).toBe('median'); + }); + + it('setSideB merges partial side B selection', () => { + setSideB({ runs: ['uuid-1', 'uuid-2'], runAgg: 'mean' }); + const s = getState(); + expect(s.sideB.runs).toEqual(['uuid-1', 'uuid-2']); + expect(s.sideB.runAgg).toBe('mean'); + // Unset fields keep their defaults + expect(s.sideB.order).toBe(''); + expect(s.sideB.machine).toBe(''); + }); + + it('state is preserved across calls (not reset)', () => { + setState({ metric: 'exec_time' }); + setState({ noise: 3 }); + setSideA({ order: 'rev1' }); + setSideA({ machine: 'mach-a' }); + setSideB({ order: 'rev2' }); + + const s = getState(); + // All previous calls should have been preserved + expect(s.metric).toBe('exec_time'); + expect(s.noise).toBe(3); + expect(s.sideA.order).toBe('rev1'); + expect(s.sideA.machine).toBe('mach-a'); + expect(s.sideB.order).toBe('rev2'); + }); + + it('swapSides exchanges sideA and sideB', () => { + setSideA({ order: 'rev1', machine: 'mach-a', runs: ['u1'], runAgg: 'mean' }); + setSideB({ order: 'rev2', machine: 'mach-b', runs: ['u2', 'u3'], runAgg: 'max' }); + + swapSides(); + + const s = getState(); + expect(s.sideA).toEqual({ order: 'rev2', machine: 'mach-b', runs: ['u2', 'u3'], runAgg: 'max' }); + expect(s.sideB).toEqual({ order: 'rev1', machine: 'mach-a', runs: ['u1'], runAgg: 'mean' }); + }); + + it('swapSides twice restores original state', () => { + setSideA({ order: 'rev1', machine: 'mach-a' }); + setSideB({ order: 'rev2', machine: 'mach-b' }); + + swapSides(); + swapSides(); + + const s = getState(); + expect(s.sideA.order).toBe('rev1'); + expect(s.sideA.machine).toBe('mach-a'); + expect(s.sideB.order).toBe('rev2'); + expect(s.sideB.machine).toBe('mach-b'); + }); +}); + +describe('URL special characters round-trip', () => { + it('round-trips order and machine with spaces', () => { + const state = makeDefaults(); + state.sideA.order = 'rev 123'; + state.sideA.machine = 'my machine'; + + const qs = encodeToUrl(state); + const decoded = decodeFromUrl(qs); + + expect(decoded.sideA?.order).toBe('rev 123'); + expect(decoded.sideA?.machine).toBe('my machine'); + }); + + it('round-trips values with +', () => { + const state = makeDefaults(); + state.sideA.order = 'r+1'; + state.sideA.machine = 'host+name'; + + const qs = encodeToUrl(state); + const decoded = decodeFromUrl(qs); + + expect(decoded.sideA?.order).toBe('r+1'); + expect(decoded.sideA?.machine).toBe('host+name'); + }); + + it('round-trips values with &', () => { + const state = makeDefaults(); + state.sideA.order = 'a&b'; + state.sideB.order = 'c&d'; + + const qs = encodeToUrl(state); + const decoded = decodeFromUrl(qs); + + expect(decoded.sideA?.order).toBe('a&b'); + expect(decoded.sideB?.order).toBe('c&d'); + }); + + it('round-trips values with =', () => { + const state = makeDefaults(); + state.sideA.machine = 'x=y'; + state.sideB.machine = 'key=value'; + + const qs = encodeToUrl(state); + const decoded = decodeFromUrl(qs); + + expect(decoded.sideA?.machine).toBe('x=y'); + expect(decoded.sideB?.machine).toBe('key=value'); + }); + + it('full round-trip with mixed special characters', () => { + const state = makeDefaults(); + state.sideA = { order: 'rev 123+rc1', machine: 'host&name=prod', runs: ['uuid-1'], runAgg: 'mean' }; + state.sideB = { order: 'a&b=c+d e', machine: 'machine two', runs: ['uuid-2', 'uuid-3'], runAgg: 'max' }; + state.metric = 'exec_time'; + state.testFilter = 'bench+suite & more'; + state.noise = 2; + state.sort = 'ratio'; + state.sortDir = 'asc'; + state.hideNoise = true; + + const qs = encodeToUrl(state); + const decoded = decodeFromUrl(qs); + + expect(decoded.sideA).toEqual(state.sideA); + expect(decoded.sideB).toEqual(state.sideB); + expect(decoded.metric).toBe(state.metric); + expect(decoded.testFilter).toBe(state.testFilter); + expect(decoded.noise).toBe(state.noise); + expect(decoded.sort).toBe(state.sort); + expect(decoded.sortDir).toBe(state.sortDir); + expect(decoded.hideNoise).toBe(state.hideNoise); + }); +}); + +describe('decodeFromUrl noise edge cases', () => { + it('noise=0 produces { noise: 0 }', () => { + const result = decodeFromUrl('?noise=0'); + expect(result.noise).toBe(0); + }); + + it('noise=abc does NOT produce a noise field (NaN rejected)', () => { + const result = decodeFromUrl('?noise=abc'); + expect(result.noise).toBeUndefined(); + }); + + it('noise=-1 does NOT produce a noise field (negative rejected)', () => { + const result = decodeFromUrl('?noise=-1'); + expect(result.noise).toBeUndefined(); + }); + + it('noise=5 produces { noise: 5 }', () => { + const result = decodeFromUrl('?noise=5'); + expect(result.noise).toBe(5); + }); +}); + +describe('replaceUrl', () => { + beforeEach(() => { + applyUrlState(''); + }); + + it('calls window.history.replaceState with the encoded URL', () => { + const spy = vi.spyOn(window.history, 'replaceState').mockImplementation(() => {}); + + // setState auto-calls replaceUrl + setState({ metric: 'compile_time', sort: 'ratio', sortDir: 'asc' }); + + expect(spy).toHaveBeenCalledOnce(); + const url = spy.mock.calls[0][2] as string; + expect(url).toContain('metric=compile_time'); + expect(url).toContain('sort=ratio'); + expect(url).toContain('sort_dir=asc'); + // First two arguments should be null and '' + expect(spy.mock.calls[0][0]).toBeNull(); + expect(spy.mock.calls[0][1]).toBe(''); + + spy.mockRestore(); + }); + + it('includes pathname in the URL', () => { + const spy = vi.spyOn(window.history, 'replaceState').mockImplementation(() => {}); + + Object.defineProperty(window, 'location', { + value: { ...window.location, pathname: '/v5/nts/compare' }, + writable: true, + configurable: true, + }); + + setState({ metric: 'exec_time' }); + replaceUrl(); + + const url = spy.mock.calls[0][2] as string; + expect(url).toMatch(/^\/v5\/nts\/compare\?/); + + spy.mockRestore(); + }); + + it('replaces with pathname only when state is all defaults', () => { + const spy = vi.spyOn(window.history, 'replaceState').mockImplementation(() => {}); + + Object.defineProperty(window, 'location', { + value: { ...window.location, pathname: '/compare' }, + writable: true, + configurable: true, + }); + + // State is already defaults from beforeEach + replaceUrl(); + + const url = spy.mock.calls[0][2] as string; + expect(url).toBe('/compare'); + + spy.mockRestore(); + }); +}); diff --git a/lnt/server/ui/v5/frontend/src/__tests__/table.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/table.test.ts new file mode 100644 index 000000000..67cb0e92f --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/__tests__/table.test.ts @@ -0,0 +1,503 @@ +// @vitest-environment jsdom +import { describe, it, expect, vi } from 'vitest'; +import { sortRows, renderTable, resetTable } from '../table'; +import type { ComparisonRow, SortCol, SortDir } from '../types'; + +// Helper to create a ComparisonRow with defaults +function makeRow(overrides: Partial<ComparisonRow> & { test: string }): ComparisonRow { + return { + valueA: null, + valueB: null, + delta: null, + deltaPct: null, + ratio: null, + status: 'unchanged', + sidePresent: 'both', + ...overrides, + }; +} + +// Reusable test data +function makeTestRows(): ComparisonRow[] { + return [ + makeRow({ test: 'bench/compile', valueA: 100, valueB: 110, delta: 10, deltaPct: 10, ratio: 1.1, status: 'regressed' }), + makeRow({ test: 'bench/link', valueA: 50, valueB: 45, delta: -5, deltaPct: -10, ratio: 0.9, status: 'improved' }), + makeRow({ test: 'bench/run', valueA: 200, valueB: 200, delta: 0, deltaPct: 0, ratio: 1.0, status: 'unchanged' }), + makeRow({ test: 'bench/alloc', valueA: 75, valueB: 80, delta: 5, deltaPct: 6.67, ratio: 1.0667, status: 'noise' }), + ]; +} + +describe('sortRows', () => { + describe('sort by test name (string column)', () => { + it('sorts ascending alphabetically', () => { + const rows = makeTestRows(); + const sorted = sortRows(rows, 'test', 'asc'); + expect(sorted.map(r => r.test)).toEqual([ + 'bench/alloc', + 'bench/compile', + 'bench/link', + 'bench/run', + ]); + }); + + it('sorts descending alphabetically', () => { + const rows = makeTestRows(); + const sorted = sortRows(rows, 'test', 'desc'); + expect(sorted.map(r => r.test)).toEqual([ + 'bench/run', + 'bench/link', + 'bench/compile', + 'bench/alloc', + ]); + }); + }); + + describe('sort by value_a (numeric column)', () => { + it('sorts ascending by value_a', () => { + const rows = makeTestRows(); + const sorted = sortRows(rows, 'value_a', 'asc'); + expect(sorted.map(r => r.valueA)).toEqual([50, 75, 100, 200]); + }); + + it('sorts descending by value_a', () => { + const rows = makeTestRows(); + const sorted = sortRows(rows, 'value_a', 'desc'); + expect(sorted.map(r => r.valueA)).toEqual([200, 100, 75, 50]); + }); + }); + + describe('sort by value_b', () => { + it('sorts ascending by value_b', () => { + const rows = makeTestRows(); + const sorted = sortRows(rows, 'value_b', 'asc'); + expect(sorted.map(r => r.valueB)).toEqual([45, 80, 110, 200]); + }); + + it('sorts descending by value_b', () => { + const rows = makeTestRows(); + const sorted = sortRows(rows, 'value_b', 'desc'); + expect(sorted.map(r => r.valueB)).toEqual([200, 110, 80, 45]); + }); + }); + + describe('sort by delta', () => { + it('sorts ascending by delta', () => { + const rows = makeTestRows(); + const sorted = sortRows(rows, 'delta', 'asc'); + expect(sorted.map(r => r.delta)).toEqual([-5, 0, 5, 10]); + }); + + it('sorts descending by delta', () => { + const rows = makeTestRows(); + const sorted = sortRows(rows, 'delta', 'desc'); + expect(sorted.map(r => r.delta)).toEqual([10, 5, 0, -5]); + }); + }); + + describe('sort by delta_pct', () => { + it('sorts ascending by delta_pct', () => { + const rows = makeTestRows(); + const sorted = sortRows(rows, 'delta_pct', 'asc'); + expect(sorted.map(r => r.deltaPct)).toEqual([-10, 0, 6.67, 10]); + }); + + it('sorts descending by delta_pct', () => { + const rows = makeTestRows(); + const sorted = sortRows(rows, 'delta_pct', 'desc'); + expect(sorted.map(r => r.deltaPct)).toEqual([10, 6.67, 0, -10]); + }); + }); + + describe('sort by ratio', () => { + it('sorts ascending by ratio', () => { + const rows = makeTestRows(); + const sorted = sortRows(rows, 'ratio', 'asc'); + expect(sorted.map(r => r.ratio)).toEqual([0.9, 1.0, 1.0667, 1.1]); + }); + + it('sorts descending by ratio', () => { + const rows = makeTestRows(); + const sorted = sortRows(rows, 'ratio', 'desc'); + expect(sorted.map(r => r.ratio)).toEqual([1.1, 1.0667, 1.0, 0.9]); + }); + }); + + describe('sort by status (string column)', () => { + it('sorts ascending by status', () => { + const rows = makeTestRows(); + const sorted = sortRows(rows, 'status', 'asc'); + expect(sorted.map(r => r.status)).toEqual([ + 'improved', + 'noise', + 'regressed', + 'unchanged', + ]); + }); + + it('sorts descending by status', () => { + const rows = makeTestRows(); + const sorted = sortRows(rows, 'status', 'desc'); + expect(sorted.map(r => r.status)).toEqual([ + 'unchanged', + 'regressed', + 'noise', + 'improved', + ]); + }); + }); + + describe('null handling', () => { + it('pushes null values to the end regardless of sort direction (ascending)', () => { + const rows = [ + makeRow({ test: 'a', valueA: 50 }), + makeRow({ test: 'b', valueA: null }), + makeRow({ test: 'c', valueA: 100 }), + makeRow({ test: 'd', valueA: null }), + ]; + const sorted = sortRows(rows, 'value_a', 'asc'); + expect(sorted.map(r => r.valueA)).toEqual([50, 100, null, null]); + }); + + it('pushes null values to the end regardless of sort direction (descending)', () => { + const rows = [ + makeRow({ test: 'a', valueA: 50 }), + makeRow({ test: 'b', valueA: null }), + makeRow({ test: 'c', valueA: 100 }), + makeRow({ test: 'd', valueA: null }), + ]; + const sorted = sortRows(rows, 'value_a', 'desc'); + expect(sorted.map(r => r.valueA)).toEqual([100, 50, null, null]); + }); + + it('handles all-null columns', () => { + const rows = [ + makeRow({ test: 'a', delta: null }), + makeRow({ test: 'b', delta: null }), + makeRow({ test: 'c', delta: null }), + ]; + const sorted = sortRows(rows, 'delta', 'asc'); + // All null, order should be stable (all compare equal) + expect(sorted).toHaveLength(3); + expect(sorted.every(r => r.delta === null)).toBe(true); + }); + + it('sorts non-null values correctly when mixed with nulls in delta_pct', () => { + const rows = [ + makeRow({ test: 'a', deltaPct: null }), + makeRow({ test: 'b', deltaPct: 5 }), + makeRow({ test: 'c', deltaPct: -3 }), + makeRow({ test: 'd', deltaPct: null }), + makeRow({ test: 'e', deltaPct: 10 }), + ]; + const sorted = sortRows(rows, 'delta_pct', 'asc'); + expect(sorted.map(r => r.deltaPct)).toEqual([-3, 5, 10, null, null]); + }); + + it('sorts non-null values correctly when mixed with nulls in ratio descending', () => { + const rows = [ + makeRow({ test: 'a', ratio: null }), + makeRow({ test: 'b', ratio: 1.5 }), + makeRow({ test: 'c', ratio: 0.8 }), + makeRow({ test: 'd', ratio: null }), + ]; + const sorted = sortRows(rows, 'ratio', 'desc'); + expect(sorted.map(r => r.ratio)).toEqual([1.5, 0.8, null, null]); + }); + + it('handles rows with only one side present (a_only has null valueB)', () => { + const rows = [ + makeRow({ test: 'both-test', valueB: 100, sidePresent: 'both' }), + makeRow({ test: 'a-only-test', valueB: null, sidePresent: 'a_only' }), + makeRow({ test: 'both-test-2', valueB: 50, sidePresent: 'both' }), + ]; + const sorted = sortRows(rows, 'value_b', 'asc'); + expect(sorted.map(r => r.valueB)).toEqual([50, 100, null]); + }); + }); + + describe('does not mutate input', () => { + it('returns a new array, not the same reference', () => { + const rows = makeTestRows(); + const sorted = sortRows(rows, 'test', 'asc'); + expect(sorted).not.toBe(rows); + }); + + it('preserves original array order after sorting', () => { + const rows = makeTestRows(); + const originalOrder = rows.map(r => r.test); + sortRows(rows, 'test', 'asc'); + expect(rows.map(r => r.test)).toEqual(originalOrder); + }); + + it('preserves original array order after sorting descending', () => { + const rows = makeTestRows(); + const originalOrder = rows.map(r => r.test); + sortRows(rows, 'delta_pct', 'desc'); + expect(rows.map(r => r.test)).toEqual(originalOrder); + }); + + it('preserves original array length', () => { + const rows = makeTestRows(); + const originalLength = rows.length; + sortRows(rows, 'value_a', 'asc'); + expect(rows).toHaveLength(originalLength); + }); + }); + + describe('edge cases', () => { + it('returns empty array for empty input', () => { + const sorted = sortRows([], 'test', 'asc'); + expect(sorted).toEqual([]); + }); + + it('returns single-element array unchanged', () => { + const rows = [makeRow({ test: 'only-test', valueA: 42 })]; + const sorted = sortRows(rows, 'value_a', 'desc'); + expect(sorted).toHaveLength(1); + expect(sorted[0].test).toBe('only-test'); + }); + + it('handles rows with identical values for the sort column', () => { + const rows = [ + makeRow({ test: 'a', valueA: 100 }), + makeRow({ test: 'b', valueA: 100 }), + makeRow({ test: 'c', valueA: 100 }), + ]; + const sorted = sortRows(rows, 'value_a', 'asc'); + expect(sorted).toHaveLength(3); + expect(sorted.every(r => r.valueA === 100)).toBe(true); + }); + + it('handles negative numeric values correctly', () => { + const rows = [ + makeRow({ test: 'a', delta: -10 }), + makeRow({ test: 'b', delta: -1 }), + makeRow({ test: 'c', delta: -100 }), + ]; + const sorted = sortRows(rows, 'delta', 'asc'); + expect(sorted.map(r => r.delta)).toEqual([-100, -10, -1]); + }); + + it('handles zero values correctly among positives and negatives', () => { + const rows = [ + makeRow({ test: 'a', delta: 5 }), + makeRow({ test: 'b', delta: 0 }), + makeRow({ test: 'c', delta: -5 }), + ]; + const sorted = sortRows(rows, 'delta', 'asc'); + expect(sorted.map(r => r.delta)).toEqual([-5, 0, 5]); + }); + }); +}); + +describe('geomean row', () => { + function makeRow(overrides: Partial<ComparisonRow> & { test: string }): ComparisonRow { + return { + valueA: null, + valueB: null, + delta: null, + deltaPct: null, + ratio: null, + status: 'unchanged', + sidePresent: 'both', + ...overrides, + }; + } + + it('renders a geomean row with A/B values, delta, and ratio', () => { + const container = document.createElement('div'); + const rows = [ + makeRow({ test: 'a', valueA: 100, valueB: 200, ratio: 2.0, status: 'improved' }), + makeRow({ test: 'b', valueA: 400, valueB: 3200, ratio: 8.0, status: 'regressed' }), + ]; + + renderTable(container, rows); + + const geomeanRow = container.querySelector('.geomean-row'); + expect(geomeanRow).toBeTruthy(); + const cells = geomeanRow!.querySelectorAll('td'); + expect(cells[0].textContent).toBe('Geomean'); + // geomeanA = sqrt(100*400) = 200, geomeanB = sqrt(200*3200) = 800 + expect(cells[1].textContent).not.toBe(''); // Value A filled + expect(cells[2].textContent).not.toBe(''); // Value B filled + expect(cells[3].textContent).not.toBe(''); // Delta filled + expect(cells[4].textContent).not.toBe(''); // Delta % filled + // Ratio geomean of [2, 8] = 4.0 + expect(cells[5].textContent).toBe('4.0000'); + + resetTable(); + }); + + it('excludes hidden rows from geomean computation', () => { + const container = document.createElement('div'); + // Two rows: ratio 2.0 and ratio 8.0 + // Geomean of both = sqrt(2*8) = 4.0 + // Hide 'b' (ratio 8.0) => geomean should be just ratio 2.0 + const rows = [ + makeRow({ test: 'a', valueA: 100, valueB: 200, ratio: 2.0, status: 'improved' }), + makeRow({ test: 'b', valueA: 400, valueB: 3200, ratio: 8.0, status: 'regressed' }), + ]; + + // First render with no hidden rows: geomean ratio = 4.0 + renderTable(container, rows); + let geomeanRow = container.querySelector('.geomean-row'); + expect(geomeanRow).toBeTruthy(); + let cells = geomeanRow!.querySelectorAll('td'); + expect(cells[5].textContent).toBe('4.0000'); + + resetTable(); + + // Now hide 'b': geomean should be computed from only 'a' (ratio 2.0) + renderTable(container, rows, { hiddenTests: new Set(['b']) }); + geomeanRow = container.querySelector('.geomean-row'); + expect(geomeanRow).toBeTruthy(); + cells = geomeanRow!.querySelectorAll('td'); + expect(cells[5].textContent).toBe('2.0000'); + + resetTable(); + }); + + it('updates geomean when hidden rows change (simulates toggle)', () => { + const container = document.createElement('div'); + const rows = [ + makeRow({ test: 'a', valueA: 100, valueB: 200, ratio: 2.0, status: 'improved' }), + makeRow({ test: 'b', valueA: 400, valueB: 3200, ratio: 8.0, status: 'regressed' }), + ]; + + // Start with 'a' hidden: geomean = ratio of 'b' = 8.0 + renderTable(container, rows, { hiddenTests: new Set(['a']) }); + let cells = container.querySelector('.geomean-row')!.querySelectorAll('td'); + expect(cells[5].textContent).toBe('8.0000'); + + resetTable(); + + // Un-hide 'a' (empty hidden set): geomean = sqrt(2*8) = 4.0 + renderTable(container, rows, { hiddenTests: new Set() }); + cells = container.querySelector('.geomean-row')!.querySelectorAll('td'); + expect(cells[5].textContent).toBe('4.0000'); + + resetTable(); + }); + + it('removes geomean row when all rows are hidden', () => { + const container = document.createElement('div'); + const rows = [ + makeRow({ test: 'a', valueA: 100, valueB: 200, ratio: 2.0, status: 'improved' }), + ]; + + // With the row visible, geomean exists + renderTable(container, rows); + expect(container.querySelector('.geomean-row')).toBeTruthy(); + resetTable(); + + // With the only row hidden, geomean should be absent + renderTable(container, rows, { hiddenTests: new Set(['a']) }); + expect(container.querySelector('.geomean-row')).toBeNull(); + resetTable(); + }); + + it('does not render a geomean row when no valid ratios', () => { + const container = document.createElement('div'); + const rows = [ + makeRow({ test: 'a', sidePresent: 'a_only', status: 'missing' }), + ]; + + renderTable(container, rows); + + const geomeanRow = container.querySelector('.geomean-row'); + expect(geomeanRow).toBeNull(); + + resetTable(); + }); +}); + +describe('row visibility toggling', () => { + function makeRow(overrides: Partial<ComparisonRow> & { test: string }): ComparisonRow { + return { + valueA: 100, + valueB: 110, + delta: 10, + deltaPct: 10, + ratio: 1.1, + status: 'improved', + sidePresent: 'both', + ...overrides, + }; + } + + it('renders hidden rows with row-hidden class', () => { + const container = document.createElement('div'); + const rows = [ + makeRow({ test: 'a', status: 'improved' }), + makeRow({ test: 'b', status: 'noise' }), + ]; + const hidden = new Set(['b']); + + renderTable(container, rows, { hiddenTests: hidden }); + + const rowA = container.querySelector('tr[data-test="a"]'); + const rowB = container.querySelector('tr[data-test="b"]'); + expect(rowA).toBeTruthy(); + expect(rowB).toBeTruthy(); + expect(rowA!.classList.contains('row-hidden')).toBe(false); + expect(rowB!.classList.contains('row-hidden')).toBe(true); + + resetTable(); + }); + + it('shows all rows including noise when hiddenTests is empty', () => { + const container = document.createElement('div'); + const rows = [ + makeRow({ test: 'a', status: 'improved' }), + makeRow({ test: 'b', status: 'noise' }), + makeRow({ test: 'c', status: 'regressed' }), + ]; + + renderTable(container, rows, { hiddenTests: new Set() }); + + const dataRows = container.querySelectorAll('tr[data-test]'); + expect(dataRows).toHaveLength(3); + + resetTable(); + }); + + it('calls onToggle on single click with delay', async () => { + const container = document.createElement('div'); + const onToggle = vi.fn(); + const rows = [makeRow({ test: 'a' })]; + + renderTable(container, rows, { onToggle }); + + const row = container.querySelector('tr[data-test="a"]')!; + row.click(); + + // Not called immediately (200ms delay) + expect(onToggle).not.toHaveBeenCalled(); + + // Wait for delay + await new Promise(r => setTimeout(r, 250)); + expect(onToggle).toHaveBeenCalledWith('a'); + + resetTable(); + }); + + it('calls onIsolate on double click without triggering onToggle', async () => { + const container = document.createElement('div'); + const onToggle = vi.fn(); + const onIsolate = vi.fn(); + const rows = [makeRow({ test: 'a' })]; + + renderTable(container, rows, { onToggle, onIsolate }); + + const row = container.querySelector('tr[data-test="a"]')!; + row.click(); + row.dispatchEvent(new MouseEvent('dblclick', { bubbles: true })); + + // Wait past the single-click delay + await new Promise(r => setTimeout(r, 250)); + expect(onIsolate).toHaveBeenCalledWith('a'); + expect(onToggle).not.toHaveBeenCalled(); + + resetTable(); + }); +}); diff --git a/lnt/server/ui/v5/frontend/src/__tests__/time-series-chart.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/time-series-chart.test.ts new file mode 100644 index 000000000..4a0938ff2 --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/__tests__/time-series-chart.test.ts @@ -0,0 +1,642 @@ +// @vitest-environment jsdom +import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; +import { buildPlotlyData, createTimeSeriesChart } from '../components/time-series-chart'; +import type { TimeSeriesTrace, PinnedOrder, TimeSeriesChartOptions, ChartHandle } from '../components/time-series-chart'; +import { TRACE_SEP } from '../pages/graph'; + +function makeTrace(name: string, points: Array<{ orderValue: string; value: number }>, machine = 'm1'): TimeSeriesTrace { + return { + testName: name, + machine, + points: points.map(p => ({ ...p, runCount: 1, timestamp: null })), + }; +} + +describe('buildPlotlyData', () => { + it('builds one Plotly trace per test', () => { + const opts: TimeSeriesChartOptions = { + traces: [ + makeTrace('test-A', [{ orderValue: '100', value: 1.5 }, { orderValue: '101', value: 2.0 }]), + makeTrace('test-B', [{ orderValue: '100', value: 3.0 }]), + ], + yAxisLabel: 'exec_time', + }; + + const { data } = buildPlotlyData(opts); + expect(data).toHaveLength(2); + const trace0 = data[0] as { x: string[]; y: number[]; name: string }; + expect(trace0.name).toBe(`test-A${TRACE_SEP}m1`); + expect(trace0.x).toEqual(['100', '101']); + expect(trace0.y).toEqual([1.5, 2.0]); + }); + + it('sets x-axis to category type', () => { + const opts: TimeSeriesChartOptions = { + traces: [makeTrace('t', [{ orderValue: '100', value: 1.0 }])], + yAxisLabel: 'metric', + }; + + const { layout } = buildPlotlyData(opts); + expect((layout as { xaxis: { type: string } }).xaxis.type).toBe('category'); + }); + + it('includes customdata for hover template', () => { + const opts: TimeSeriesChartOptions = { + traces: [makeTrace('test-A', [{ orderValue: '100', value: 1.5 }])], + yAxisLabel: 'metric', + }; + + const { data } = buildPlotlyData(opts); + const trace = data[0] as { customdata: string[][] }; + expect(trace.customdata[0][0]).toBe('100'); // orderValue + expect(trace.customdata[0][1]).toBe(`test-A${TRACE_SEP}m1`); // traceName + expect(trace.customdata[0][4]).toBe('test-A'); // testName + expect(trace.customdata[0][5]).toBe('m1'); // machine + }); + + it('generates reference order traces with hover', () => { + const refValues = new Map<string, number>(); + refValues.set('test-A', 2.5); + + const opts: TimeSeriesChartOptions = { + traces: [makeTrace('test-A', [{ orderValue: '100', value: 1.5 }, { orderValue: '102', value: 2.0 }])], + yAxisLabel: 'metric', + pinnedOrders: [{ + orderValue: '101', + tag: 'release-18', + values: refValues, + color: '#e377c2', + }], + }; + + const { data } = buildPlotlyData(opts); + // 1 main trace + 1 reference trace + expect(data).toHaveLength(2); + const refTrace = data[1] as { + x: string[]; y: number[]; mode: string; + line: { dash: string; color: string }; + showlegend: boolean; hovertemplate: string; + }; + expect(refTrace.y).toEqual([2.5, 2.5]); + expect(refTrace.mode).toBe('lines'); + expect(refTrace.line.dash).toBe('dot'); + expect(refTrace.line.color).toBe('#e377c2'); + expect(refTrace.showlegend).toBe(false); + expect(refTrace.hovertemplate).toContain('Pinned: 101 (release-18)'); + expect(refTrace.hovertemplate).toContain('test-A'); + expect(refTrace.hovertemplate).toContain('2.500'); + }); + + it('HTML-escapes user-controlled values in pinned order hover templates', () => { + const refValues = new Map<string, number>(); + refValues.set('<script>alert("xss")</script>', 3.0); + + const opts: TimeSeriesChartOptions = { + traces: [makeTrace('<script>alert("xss")</script>', [{ orderValue: '100', value: 1.5 }])], + yAxisLabel: 'metric', + pinnedOrders: [{ + orderValue: '101', + tag: '<img onerror=alert(1)>', + values: refValues, + color: '#e377c2', + }], + }; + + const { data } = buildPlotlyData(opts); + const refTrace = data[1] as { hovertemplate: string }; + // Verify that HTML special characters are escaped + expect(refTrace.hovertemplate).not.toContain('<script>'); + expect(refTrace.hovertemplate).not.toContain('<img'); + expect(refTrace.hovertemplate).toContain('<script>'); + expect(refTrace.hovertemplate).toContain('<img onerror=alert(1)>'); + }); + + it('uses all scaffold categories for reference trace x-values', () => { + const refValues = new Map<string, number>(); + refValues.set('test-A', 2.5); + + const opts: TimeSeriesChartOptions = { + traces: [makeTrace('test-A', [{ orderValue: '102', value: 1.5 }, { orderValue: '103', value: 2.0 }])], + yAxisLabel: 'metric', + categoryOrder: ['100', '101', '102', '103', '104', '105'], + pinnedOrders: [{ + orderValue: '101', + tag: null, + values: refValues, + color: '#e377c2', + }], + }; + + const { data } = buildPlotlyData(opts); + const refTrace = data[1] as { x: string[]; y: number[] }; + // x-values include every scaffold category (for hover detection along the line) + expect(refTrace.x).toEqual(['100', '101', '102', '103', '104', '105']); + expect(refTrace.y).toEqual([2.5, 2.5, 2.5, 2.5, 2.5, 2.5]); + }); + + it('skips reference traces for tests not in traces', () => { + const refValues = new Map<string, number>(); + refValues.set('nonexistent-test', 5.0); + + const opts: TimeSeriesChartOptions = { + traces: [makeTrace('test-A', [{ orderValue: '100', value: 1.0 }])], + yAxisLabel: 'metric', + pinnedOrders: [{ + orderValue: '100', + tag: null, + values: refValues, + color: '#ff0000', + }], + }; + + const { data } = buildPlotlyData(opts); + // Only the main trace, no reference trace (test not found) + expect(data).toHaveLength(1); + }); + + it('hides legend when only one trace', () => { + const opts: TimeSeriesChartOptions = { + traces: [makeTrace('t', [{ orderValue: '100', value: 1.0 }])], + yAxisLabel: 'metric', + }; + + const { layout } = buildPlotlyData(opts); + expect((layout as { showlegend: boolean }).showlegend).toBe(false); + }); + + it('sets categoryarray when categoryOrder is provided', () => { + const opts: TimeSeriesChartOptions = { + traces: [makeTrace('t', [{ orderValue: '102', value: 1.0 }])], + yAxisLabel: 'metric', + categoryOrder: ['100', '101', '102', '103'], + }; + + const { layout } = buildPlotlyData(opts); + const xaxis = (layout as { xaxis: Record<string, unknown> }).xaxis; + expect(xaxis.categoryorder).toBe('array'); + expect(xaxis.categoryarray).toEqual(['100', '101', '102', '103']); + }); + + it('does not set categoryarray when categoryOrder is omitted', () => { + const opts: TimeSeriesChartOptions = { + traces: [makeTrace('t', [{ orderValue: '100', value: 1.0 }])], + yAxisLabel: 'metric', + }; + + const { layout } = buildPlotlyData(opts); + const xaxis = (layout as { xaxis: Record<string, unknown> }).xaxis; + expect(xaxis.categoryorder).toBeUndefined(); + expect(xaxis.categoryarray).toBeUndefined(); + }); + + it('always hides built-in legend (replaced by legend table)', () => { + const opts: TimeSeriesChartOptions = { + traces: [ + makeTrace('t1', [{ orderValue: '100', value: 1.0 }]), + makeTrace('t2', [{ orderValue: '100', value: 2.0 }]), + ], + yAxisLabel: 'metric', + }; + + const { layout } = buildPlotlyData(opts); + expect((layout as { showlegend: boolean }).showlegend).toBe(false); + }); +}); + +// =========================================================================== +// createTimeSeriesChart +// =========================================================================== + +describe('createTimeSeriesChart', () => { + let mockNewPlot: ReturnType<typeof vi.fn>; + let mockReact: ReturnType<typeof vi.fn>; + let mockPurge: ReturnType<typeof vi.fn>; + let mockRestyle: ReturnType<typeof vi.fn>; + let mockAddTraces: ReturnType<typeof vi.fn>; + let mockDeleteTraces: ReturnType<typeof vi.fn>; + let mockRelayout: ReturnType<typeof vi.fn>; + + beforeEach(() => { + // Mock Plotly on globalThis + const mockGd = document.createElement('div'); + (mockGd as unknown as { on: ReturnType<typeof vi.fn> }).on = vi.fn(); + + mockNewPlot = vi.fn().mockResolvedValue(mockGd); + mockReact = vi.fn().mockResolvedValue(mockGd); + mockPurge = vi.fn(); + mockRestyle = vi.fn(); + mockAddTraces = vi.fn(); + mockDeleteTraces = vi.fn(); + mockRelayout = vi.fn(); + + vi.stubGlobal('Plotly', { + newPlot: mockNewPlot, + react: mockReact, + purge: mockPurge, + restyle: mockRestyle, + addTraces: mockAddTraces, + deleteTraces: mockDeleteTraces, + relayout: mockRelayout, + }); + }); + + afterEach(() => { + vi.unstubAllGlobals(); + }); + + it('calls Plotly.newPlot on creation', () => { + const container = document.createElement('div'); + createTimeSeriesChart(container, { + traces: [makeTrace('t1', [{ orderValue: '100', value: 1.0 }])], + yAxisLabel: 'metric', + }); + + expect(mockNewPlot).toHaveBeenCalledTimes(1); + expect(mockReact).not.toHaveBeenCalled(); + }); + + it('calls Plotly.react on update()', async () => { + const container = document.createElement('div'); + const handle = createTimeSeriesChart(container, { + traces: [makeTrace('t1', [{ orderValue: '100', value: 1.0 }])], + yAxisLabel: 'metric', + }); + + handle.update({ + traces: [makeTrace('t1', [{ orderValue: '100', value: 2.0 }])], + yAxisLabel: 'metric', + }); + + // react() is chained after newPlot() resolves — flush microtasks + await new Promise(r => setTimeout(r, 0)); + + expect(mockNewPlot).toHaveBeenCalledTimes(1); + expect(mockReact).toHaveBeenCalledTimes(1); + }); + + it('calls Plotly.purge on destroy()', () => { + const container = document.createElement('div'); + const handle = createTimeSeriesChart(container, { + traces: [makeTrace('t1', [{ orderValue: '100', value: 1.0 }])], + yAxisLabel: 'metric', + }); + + handle.destroy(); + + expect(mockPurge).toHaveBeenCalledTimes(1); + }); + + it('shows "No data to plot" for zero traces', () => { + const container = document.createElement('div'); + createTimeSeriesChart(container, { + traces: [], + yAxisLabel: 'metric', + }); + + expect(container.textContent).toContain('No data to plot'); + expect(mockNewPlot).not.toHaveBeenCalled(); + }); + + it('replaces "No data" message with chart on update with data', () => { + const container = document.createElement('div'); + const handle = createTimeSeriesChart(container, { + traces: [], + yAxisLabel: 'metric', + }); + + handle.update({ + traces: [makeTrace('t1', [{ orderValue: '100', value: 1.0 }])], + yAxisLabel: 'metric', + }); + + expect(mockNewPlot).toHaveBeenCalledTimes(1); + expect(container.querySelector('.graph-chart')).not.toBeNull(); + }); + + it('preserves x-axis range on update()', async () => { + const container = document.createElement('div'); + + // Mock newPlot to set .layout on the chart div (simulating Plotly behavior) + mockNewPlot.mockImplementation((div: HTMLElement) => { + (div as unknown as { layout: unknown }).layout = { + xaxis: { range: [10, 50], autorange: false }, + yaxis: { autorange: true }, + }; + const gd = div as unknown as { on: ReturnType<typeof vi.fn> }; + gd.on = vi.fn(); + return Promise.resolve(div); + }); + + const handle = createTimeSeriesChart(container, { + traces: [makeTrace('t1', [{ orderValue: '100', value: 1.0 }])], + yAxisLabel: 'metric', + categoryOrder: ['100', '101', '102'], + }); + + handle.update({ + traces: [makeTrace('t1', [{ orderValue: '100', value: 2.0 }, { orderValue: '101', value: 3.0 }])], + yAxisLabel: 'metric', + categoryOrder: ['100', '101', '102'], + }); + + await new Promise(r => setTimeout(r, 0)); + + expect(mockReact).toHaveBeenCalledTimes(1); + const layout = mockReact.mock.calls[0][2] as { xaxis: { range: unknown; autorange: unknown } }; + expect(layout.xaxis.range).toEqual([10, 50]); + expect(layout.xaxis.autorange).toBe(false); + }); + + it('preserves y-axis range when user has zoomed (autorange=false)', async () => { + const container = document.createElement('div'); + + mockNewPlot.mockImplementation((div: HTMLElement) => { + (div as unknown as { layout: unknown }).layout = { + xaxis: { range: [-0.5, 2.5], autorange: false }, + yaxis: { range: [1.0, 5.0], autorange: false }, + }; + const gd = div as unknown as { on: ReturnType<typeof vi.fn> }; + gd.on = vi.fn(); + return Promise.resolve(div); + }); + + const handle = createTimeSeriesChart(container, { + traces: [makeTrace('t1', [{ orderValue: '100', value: 1.0 }])], + yAxisLabel: 'metric', + }); + + handle.update({ + traces: [makeTrace('t1', [{ orderValue: '100', value: 2.0 }])], + yAxisLabel: 'metric', + }); + + await new Promise(r => setTimeout(r, 0)); + + const layout = mockReact.mock.calls[0][2] as { yaxis: { range: unknown; autorange: unknown } }; + expect(layout.yaxis.range).toEqual([1.0, 5.0]); + expect(layout.yaxis.autorange).toBe(false); + }); + + it('does not set y-axis range when autorange is true (no user zoom)', async () => { + const container = document.createElement('div'); + + mockNewPlot.mockImplementation((div: HTMLElement) => { + (div as unknown as { layout: unknown }).layout = { + xaxis: { range: [-0.5, 2.5], autorange: false }, + yaxis: { autorange: true }, + }; + const gd = div as unknown as { on: ReturnType<typeof vi.fn> }; + gd.on = vi.fn(); + return Promise.resolve(div); + }); + + const handle = createTimeSeriesChart(container, { + traces: [makeTrace('t1', [{ orderValue: '100', value: 1.0 }])], + yAxisLabel: 'metric', + }); + + handle.update({ + traces: [makeTrace('t1', [{ orderValue: '100', value: 2.0 }])], + yAxisLabel: 'metric', + }); + + await new Promise(r => setTimeout(r, 0)); + + const layout = mockReact.mock.calls[0][2] as { yaxis: { range?: unknown; autorange?: unknown } }; + // yaxis should NOT have an explicit range — let Plotly auto-range + expect(layout.yaxis.autorange).toBeUndefined(); + expect(layout.yaxis.range).toBeUndefined(); + }); + + it('does not set explicit ranges after zoom reset (autorange=true on both axes)', async () => { + const container = document.createElement('div'); + + mockNewPlot.mockImplementation((div: HTMLElement) => { + // Simulate state after double-click zoom reset + (div as unknown as { layout: unknown }).layout = { + xaxis: { range: [-0.5, 2.5], autorange: true }, + yaxis: { autorange: true }, + }; + const gd = div as unknown as { on: ReturnType<typeof vi.fn> }; + gd.on = vi.fn(); + return Promise.resolve(div); + }); + + const handle = createTimeSeriesChart(container, { + traces: [makeTrace('t1', [{ orderValue: '100', value: 1.0 }])], + yAxisLabel: 'metric', + categoryOrder: ['100', '101', '102'], + }); + + handle.update({ + traces: [makeTrace('t1', [{ orderValue: '100', value: 2.0 }])], + yAxisLabel: 'metric', + categoryOrder: ['100', '101', '102'], + }); + + await new Promise(r => setTimeout(r, 0)); + + const layout = mockReact.mock.calls[0][2] as { + xaxis: { range: unknown; autorange: unknown }; + yaxis: { range?: unknown; autorange?: unknown }; + }; + // X-axis preserves whatever Plotly has (autorange=true from double-click) + expect(layout.xaxis.autorange).toBe(true); + // Y-axis should not have explicit range + expect(layout.yaxis.autorange).toBeUndefined(); + expect(layout.yaxis.range).toBeUndefined(); + }); + + it('hoverTrace() calls restyle to emphasize one trace and dim others', async () => { + const container = document.createElement('div'); + const handle = createTimeSeriesChart(container, { + traces: [ + makeTrace('test-A', [{ orderValue: '100', value: 1.0 }]), + makeTrace('test-B', [{ orderValue: '100', value: 2.0 }]), + makeTrace('test-C', [{ orderValue: '100', value: 3.0 }]), + ], + yAxisLabel: 'metric', + }); + + // Wait for newPlot to resolve + await new Promise(r => setTimeout(r, 0)); + + handle.hoverTrace(`test-B${TRACE_SEP}m1`); + await new Promise(r => setTimeout(r, 0)); + + // First call: dim all 3 traces + expect(mockRestyle).toHaveBeenCalledTimes(2); + expect(mockRestyle.mock.calls[0][1]).toEqual({ opacity: 0.2, 'line.width': 1.5 }); + expect(mockRestyle.mock.calls[0][2]).toEqual([0, 1, 2]); + // Second call: emphasize trace index 1 (test-B) + expect(mockRestyle.mock.calls[1][1]).toEqual({ opacity: 1.0, 'line.width': 3 }); + expect(mockRestyle.mock.calls[1][2]).toEqual([1]); + }); + + it('hoverTrace(null) restores all traces to normal', async () => { + const container = document.createElement('div'); + const handle = createTimeSeriesChart(container, { + traces: [ + makeTrace('test-A', [{ orderValue: '100', value: 1.0 }]), + makeTrace('test-B', [{ orderValue: '100', value: 2.0 }]), + ], + yAxisLabel: 'metric', + }); + + await new Promise(r => setTimeout(r, 0)); + + handle.hoverTrace(null); + await new Promise(r => setTimeout(r, 0)); + + expect(mockRestyle).toHaveBeenCalledTimes(1); + expect(mockRestyle.mock.calls[0][1]).toEqual({ opacity: 1.0, 'line.width': 1.5 }); + expect(mockRestyle.mock.calls[0][2]).toEqual([0, 1]); + }); + + it('hoverTrace() dims reference-order traces along with non-hovered main traces', async () => { + const container = document.createElement('div'); + const refValues = new Map<string, number>(); + refValues.set('test-A', 5.0); + + const handle = createTimeSeriesChart(container, { + traces: [ + makeTrace('test-A', [{ orderValue: '100', value: 1.0 }]), + makeTrace('test-B', [{ orderValue: '100', value: 2.0 }]), + ], + yAxisLabel: 'metric', + pinnedOrders: [{ + orderValue: '100', tag: null, values: refValues, color: '#e377c2', + }], + }); + + await new Promise(r => setTimeout(r, 0)); + + handle.hoverTrace(`test-A${TRACE_SEP}m1`); + await new Promise(r => setTimeout(r, 0)); + + // 2 main traces + 1 reference trace = 3 total + expect(mockRestyle.mock.calls[0][1]).toEqual({ opacity: 0.2, 'line.width': 1.5 }); + expect(mockRestyle.mock.calls[0][2]).toEqual([0, 1, 2]); + // Emphasize only trace 0 (test-A · m1) + expect(mockRestyle.mock.calls[1][1]).toEqual({ opacity: 1.0, 'line.width': 3 }); + expect(mockRestyle.mock.calls[1][2]).toEqual([0]); + }); + + it('shows scatter trace on hover when getRawValues returns >1 values', async () => { + const container = document.createElement('div'); + // Capture the gd.on handlers + const handlers = new Map<string, Function>(); + const mockGd = document.createElement('div'); + (mockGd as unknown as { on: ReturnType<typeof vi.fn> }).on = vi.fn( + (evt: string, cb: Function) => { handlers.set(evt, cb); }, + ); + mockNewPlot.mockResolvedValue(mockGd); + + createTimeSeriesChart(container, { + traces: [ + { testName: 'test-A', machine: 'm1', color: '#1f77b4', points: [{ orderValue: '100', value: 2.0, runCount: 3, timestamp: null }] }, + ], + yAxisLabel: 'metric', + getRawValues: (_test, _machine, _order) => [1.0, 2.0, 3.0], + }); + + await new Promise(r => setTimeout(r, 0)); + + // Simulate hover + const hoverHandler = handlers.get('plotly_hover'); + expect(hoverHandler).toBeDefined(); + hoverHandler!({ points: [{ customdata: ['100', `test-A${TRACE_SEP}m1`, '2.000', '3', 'test-A', 'm1'], curveNumber: 0, pointNumber: 0 }] }); + await new Promise(r => setTimeout(r, 0)); + + expect(mockAddTraces).toHaveBeenCalledTimes(1); + const scatter = mockAddTraces.mock.calls[0][1]; + expect(scatter.x).toEqual(['100', '100', '100']); + expect(scatter.y).toEqual([1.0, 2.0, 3.0]); + expect(scatter.mode).toBe('markers'); + expect(scatter.marker.color).toBe('#1f77b4'); + expect(scatter.marker.opacity).toBe(0.3); + expect(scatter.showlegend).toBe(false); + expect(scatter.hoverinfo).toBe('skip'); + }); + + it('does not show scatter when getRawValues returns <=1 values', async () => { + const container = document.createElement('div'); + const handlers = new Map<string, Function>(); + const mockGd = document.createElement('div'); + (mockGd as unknown as { on: ReturnType<typeof vi.fn> }).on = vi.fn( + (evt: string, cb: Function) => { handlers.set(evt, cb); }, + ); + mockNewPlot.mockResolvedValue(mockGd); + + createTimeSeriesChart(container, { + traces: [ + { testName: 'test-A', machine: 'm1', color: '#1f77b4', points: [{ orderValue: '100', value: 1.0, runCount: 1, timestamp: null }] }, + ], + yAxisLabel: 'metric', + getRawValues: () => [1.0], + }); + + await new Promise(r => setTimeout(r, 0)); + + handlers.get('plotly_hover')!({ points: [{ customdata: ['100', `test-A${TRACE_SEP}m1`, '1.000', '1', 'test-A', 'm1'], curveNumber: 0, pointNumber: 0 }] }); + await new Promise(r => setTimeout(r, 0)); + + expect(mockAddTraces).not.toHaveBeenCalled(); + }); + + it('removes scatter trace on unhover', async () => { + const container = document.createElement('div'); + const handlers = new Map<string, Function>(); + const mockGd = document.createElement('div'); + (mockGd as unknown as { on: ReturnType<typeof vi.fn> }).on = vi.fn( + (evt: string, cb: Function) => { handlers.set(evt, cb); }, + ); + mockNewPlot.mockResolvedValue(mockGd); + + createTimeSeriesChart(container, { + traces: [ + { testName: 'test-A', machine: 'm1', color: '#1f77b4', points: [{ orderValue: '100', value: 2.0, runCount: 3, timestamp: null }] }, + ], + yAxisLabel: 'metric', + getRawValues: () => [1.0, 2.0, 3.0], + }); + + await new Promise(r => setTimeout(r, 0)); + + // Hover to add scatter + handlers.get('plotly_hover')!({ points: [{ customdata: ['100', `test-A${TRACE_SEP}m1`, '2.000', '3', 'test-A', 'm1'], curveNumber: 0, pointNumber: 0 }] }); + await new Promise(r => setTimeout(r, 0)); + expect(mockAddTraces).toHaveBeenCalledTimes(1); + + // Unhover to remove scatter + handlers.get('plotly_unhover')!(); + await new Promise(r => setTimeout(r, 0)); + expect(mockDeleteTraces).toHaveBeenCalledTimes(1); + expect(mockDeleteTraces.mock.calls[0][1]).toEqual([-1]); + }); + + it('does not add scatter when getRawValues is not provided', async () => { + const container = document.createElement('div'); + const handlers = new Map<string, Function>(); + const mockGd = document.createElement('div'); + (mockGd as unknown as { on: ReturnType<typeof vi.fn> }).on = vi.fn( + (evt: string, cb: Function) => { handlers.set(evt, cb); }, + ); + mockNewPlot.mockResolvedValue(mockGd); + + createTimeSeriesChart(container, { + traces: [ + { testName: 'test-A', machine: 'm1', color: '#1f77b4', points: [{ orderValue: '100', value: 2.0, runCount: 3, timestamp: null }] }, + ], + yAxisLabel: 'metric', + // no getRawValues + }); + + await new Promise(r => setTimeout(r, 0)); + + handlers.get('plotly_hover')!({ points: [{ customdata: ['100', `test-A${TRACE_SEP}m1`, '2.000', '3', 'test-A', 'm1'], curveNumber: 0, pointNumber: 0 }] }); + await new Promise(r => setTimeout(r, 0)); + + expect(mockAddTraces).not.toHaveBeenCalled(); + }); +}); diff --git a/lnt/server/ui/v5/frontend/src/__tests__/utils.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/utils.test.ts new file mode 100644 index 000000000..9aa046aa7 --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/__tests__/utils.test.ts @@ -0,0 +1,337 @@ +// @vitest-environment jsdom +import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; +import { + median, mean, safeMin, safeMax, getAggFn, + formatValue, formatPercent, formatRatio, formatTime, + truncate, primaryOrderValue, + debounce, el, +} from '../utils'; + +describe('median', () => { + it('returns 0 for empty array', () => { + expect(median([])).toBe(0); + }); + + it('returns the single value', () => { + expect(median([42])).toBe(42); + }); + + it('returns middle value for odd count', () => { + expect(median([1, 3, 5])).toBe(3); + expect(median([5, 1, 3])).toBe(3); // unsorted input + }); + + it('returns average of two middle values for even count', () => { + expect(median([1, 2, 3, 4])).toBe(2.5); + expect(median([4, 1, 3, 2])).toBe(2.5); // unsorted input + }); +}); + +describe('mean', () => { + it('returns 0 for empty array', () => { + expect(mean([])).toBe(0); + }); + + it('returns the single value', () => { + expect(mean([7])).toBe(7); + }); + + it('returns average of multiple values', () => { + expect(mean([2, 4, 6])).toBe(4); + expect(mean([1, 2, 3, 4])).toBe(2.5); + }); +}); + +describe('safeMin', () => { + it('returns 0 for empty array', () => { + expect(safeMin([])).toBe(0); + }); + + it('returns the minimum value', () => { + expect(safeMin([3, 1, 2])).toBe(1); + expect(safeMin([-5, 0, 5])).toBe(-5); + }); +}); + +describe('safeMax', () => { + it('returns 0 for empty array', () => { + expect(safeMax([])).toBe(0); + }); + + it('returns the maximum value', () => { + expect(safeMax([3, 1, 2])).toBe(3); + expect(safeMax([-5, 0, 5])).toBe(5); + }); +}); + +describe('getAggFn', () => { + it('returns the correct function for each name', () => { + expect(getAggFn('median')).toBe(median); + expect(getAggFn('mean')).toBe(mean); + expect(getAggFn('min')).toBe(safeMin); + expect(getAggFn('max')).toBe(safeMax); + }); +}); + +describe('formatValue', () => { + it('returns N/A for null', () => { + expect(formatValue(null)).toBe('N/A'); + }); + + it('returns "0" for zero', () => { + expect(formatValue(0)).toBe('0'); + }); + + it('formats large numbers with 1 decimal', () => { + expect(formatValue(1234.567)).toBe('1234.6'); + expect(formatValue(-5000.1)).toBe('-5000.1'); + }); + + it('formats medium numbers with 4 significant digits', () => { + expect(formatValue(12.34)).toBe('12.34'); + expect(formatValue(1.0)).toBe('1.000'); + }); + + it('formats small numbers with 3 significant digits', () => { + expect(formatValue(0.001234)).toBe('0.00123'); + expect(formatValue(0.5)).toBe('0.500'); + }); + + it('formats negative small numbers', () => { + expect(formatValue(-0.005)).toBe('-0.00500'); + }); + + describe('edge cases', () => { + it('returns "NaN" for NaN', () => { + expect(formatValue(NaN)).toBe('NaN'); + }); + + it('returns "Infinity" for Infinity', () => { + expect(formatValue(Infinity)).toBe('Infinity'); + }); + + it('returns "-Infinity" for -Infinity', () => { + expect(formatValue(-Infinity)).toBe('-Infinity'); + }); + + it('returns "0" for zero', () => { + expect(formatValue(0)).toBe('0'); + }); + }); +}); + +describe('formatPercent', () => { + it('returns N/A for null', () => { + expect(formatPercent(null)).toBe('N/A'); + }); + + it('adds + sign for positive values', () => { + expect(formatPercent(5.123)).toBe('+5.12%'); + }); + + it('keeps - sign for negative values', () => { + expect(formatPercent(-3.456)).toBe('-3.46%'); + }); + + it('formats zero without sign', () => { + expect(formatPercent(0)).toBe('0.00%'); + }); +}); + +describe('formatRatio', () => { + it('returns N/A for null', () => { + expect(formatRatio(null)).toBe('N/A'); + }); + + it('formats to 4 decimal places', () => { + expect(formatRatio(1.0)).toBe('1.0000'); + expect(formatRatio(0.9876)).toBe('0.9876'); + expect(formatRatio(1.23456)).toBe('1.2346'); + }); +}); + +describe('debounce', () => { + beforeEach(() => { + vi.useFakeTimers(); + }); + + afterEach(() => { + vi.useRealTimers(); + }); + + it('delays execution by the specified ms', () => { + const fn = vi.fn(); + const debounced = debounce(fn, 200); + + debounced(); + expect(fn).not.toHaveBeenCalled(); + + vi.advanceTimersByTime(199); + expect(fn).not.toHaveBeenCalled(); + + vi.advanceTimersByTime(1); + expect(fn).toHaveBeenCalledOnce(); + }); + + it('only executes the last of multiple rapid calls', () => { + const fn = vi.fn(); + const debounced = debounce(fn, 100); + + debounced(); + debounced(); + debounced(); + + vi.advanceTimersByTime(100); + expect(fn).toHaveBeenCalledOnce(); + }); + + it('is actually called after the delay', () => { + const fn = vi.fn(); + const debounced = debounce(fn, 50); + + debounced(); + vi.advanceTimersByTime(50); + + expect(fn).toHaveBeenCalledTimes(1); + }); + + it('passes arguments through correctly', () => { + const fn = vi.fn(); + const debounced = debounce(fn, 100); + + debounced('hello', 42); + vi.advanceTimersByTime(100); + + expect(fn).toHaveBeenCalledWith('hello', 42); + }); + + it('resets the timer when called again before it fires', () => { + const fn = vi.fn(); + const debounced = debounce(fn, 100); + + debounced(); + vi.advanceTimersByTime(80); + expect(fn).not.toHaveBeenCalled(); + + // Call again — this should reset the 100ms timer + debounced(); + vi.advanceTimersByTime(80); + expect(fn).not.toHaveBeenCalled(); + + // 20ms more completes the second timer (80 + 20 = 100 from second call) + vi.advanceTimersByTime(20); + expect(fn).toHaveBeenCalledOnce(); + }); +}); + +describe('el', () => { + it('creates an element with the correct tag name', () => { + const div = el('div'); + expect(div.tagName).toBe('DIV'); + + const span = el('span'); + expect(span.tagName).toBe('SPAN'); + }); + + it('sets string attributes via setAttribute', () => { + const input = el('input', { type: 'text', id: 'my-input', class: 'form-control' }); + expect(input.getAttribute('type')).toBe('text'); + expect(input.getAttribute('id')).toBe('my-input'); + expect(input.getAttribute('class')).toBe('form-control'); + }); + + it('handles boolean attributes: true sets empty attribute, false omits it', () => { + const input = el('input', { disabled: true, hidden: false }); + expect(input.hasAttribute('disabled')).toBe(true); + expect(input.getAttribute('disabled')).toBe(''); + expect(input.hasAttribute('hidden')).toBe(false); + }); + + it('appends string children as text nodes', () => { + const p = el('p', undefined, 'Hello, world!'); + expect(p.childNodes.length).toBe(1); + expect(p.textContent).toBe('Hello, world!'); + }); + + it('appends Node children (e.g., another element)', () => { + const child = el('span'); + const parent = el('div', undefined, child); + expect(parent.childNodes.length).toBe(1); + expect(parent.firstChild).toBe(child); + }); + + it('appends multiple children in order', () => { + const first = el('span', undefined, 'first'); + const second = el('em', undefined, 'second'); + const parent = el('div', undefined, first, 'middle', second); + + expect(parent.childNodes.length).toBe(3); + expect(parent.childNodes[0]).toBe(first); + expect(parent.childNodes[1].textContent).toBe('middle'); + expect(parent.childNodes[2]).toBe(second); + }); + + it('works correctly with no attributes (undefined)', () => { + const div = el('div', undefined, 'content'); + expect(div.tagName).toBe('DIV'); + expect(div.attributes.length).toBe(0); + expect(div.textContent).toBe('content'); + }); +}); + +describe('formatTime', () => { + it('returns em-dash for null', () => { + expect(formatTime(null)).toBe('\u2014'); + }); + + it('returns empty string for null when custom fallback is empty', () => { + expect(formatTime(null, '')).toBe(''); + }); + + it('returns custom fallback for null', () => { + expect(formatTime(null, 'N/A')).toBe('N/A'); + }); + + it('returns em-dash for empty string', () => { + expect(formatTime('')).toBe('\u2014'); + }); + + it('returns a locale string for a valid ISO date', () => { + const result = formatTime('2025-01-15T10:30:00'); + // Just verify it returns a non-empty string (locale formatting varies) + expect(result.length).toBeGreaterThan(0); + expect(result).not.toBe('\u2014'); + }); +}); + +describe('truncate', () => { + it('returns original string when length <= max', () => { + expect(truncate('hello', 10)).toBe('hello'); + }); + + it('returns original string when length equals max', () => { + expect(truncate('hello', 5)).toBe('hello'); + }); + + it('truncates with ellipsis when length > max', () => { + expect(truncate('hello world', 5)).toBe('hello\u2026'); + }); + + it('handles empty string', () => { + expect(truncate('', 5)).toBe(''); + }); +}); + +describe('primaryOrderValue', () => { + it('returns first value from a single-field record', () => { + expect(primaryOrderValue({ rev: '12345' })).toBe('12345'); + }); + + it('returns first value from a multi-field record', () => { + expect(primaryOrderValue({ rev: '123', branch: 'main' })).toBe('123'); + }); + + it('returns empty string for an empty record', () => { + expect(primaryOrderValue({})).toBe(''); + }); +}); diff --git a/lnt/server/ui/v5/frontend/src/api.ts b/lnt/server/ui/v5/frontend/src/api.ts new file mode 100644 index 000000000..b115a58e6 --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/api.ts @@ -0,0 +1,412 @@ +import type { + APIKeyCreateResponse, APIKeyItem, + CursorPaginated, FieldChangeInfo, FieldInfo, MachineInfo, MachineRunInfo, + OffsetPaginated, OrderDetail, OrderSummary, QueryDataPoint, RunDetail, + RunInfo, SampleInfo, TestSuiteInfo, +} from './types'; + +let apiBase = ''; + +export function setApiBase(base: string): void { + // base should be the lnt_url_base value, e.g. "" or "/lnt" + apiBase = base.replace(/\/$/, ''); +} + +function getToken(): string | null { + return localStorage.getItem('lnt_v5_token'); +} + +/** Structured API error with HTTP status code. */ +export class ApiError extends Error { + constructor(public readonly status: number, message: string) { + super(message); + } +} + +/** Format an auth/permission error for display. */ +export function authErrorMessage(err: unknown): string { + if (err instanceof ApiError && (err.status === 401 || err.status === 403)) { + return "Permission denied. Set an API token with the required scope in Settings."; + } + return `Error: ${err}`; +} + +interface FetchOptions { + params?: Record<string, string>; + signal?: AbortSignal; + method?: string; + body?: unknown; +} + +async function fetchJson<T>(url: string, opts?: FetchOptions): Promise<T> { + const params = opts?.params; + const signal = opts?.signal; + const method = opts?.method; + const body = opts?.body; + + const u = new URL(url, window.location.origin); + if (params) { + for (const [k, v] of Object.entries(params)) { + if (v !== undefined && v !== '') u.searchParams.set(k, v); + } + } + const headers: Record<string, string> = { 'Accept': 'application/json' }; + const token = getToken(); + if (token) headers['Authorization'] = `Bearer ${token}`; + + const init: RequestInit = { headers, signal }; + if (method) init.method = method; + if (body !== undefined) { + headers['Content-Type'] = 'application/json'; + init.body = JSON.stringify(body); + } + + const resp = await fetch(u.toString(), init); + if (!resp.ok) { + const text = await resp.text().catch(() => ''); + throw new ApiError(resp.status, `API ${resp.status}: ${text || resp.statusText}`); + } + return resp.json(); +} + +/** Like fetchJson but for endpoints that return no body (e.g. DELETE → 204). */ +async function fetchVoid(url: string, opts?: FetchOptions): Promise<void> { + const u = new URL(url, window.location.origin); + if (opts?.params) { + for (const [k, v] of Object.entries(opts.params)) { + if (v !== undefined && v !== '') u.searchParams.set(k, v); + } + } + const headers: Record<string, string> = {}; + const token = getToken(); + if (token) headers['Authorization'] = `Bearer ${token}`; + + const init: RequestInit = { headers, signal: opts?.signal }; + if (opts?.method) init.method = opts.method; + + const resp = await fetch(u.toString(), init); + if (!resp.ok) { + const text = await resp.text().catch(() => ''); + throw new ApiError(resp.status, `API ${resp.status}: ${text || resp.statusText}`); + } +} + +async function fetchAllCursorPages<T>( + url: string, + params?: Record<string, string>, + signal?: AbortSignal, + onProgress?: (loaded: number) => void, +): Promise<T[]> { + const all: T[] = []; + let cursor: string | undefined; + const baseParams: Record<string, string> = { ...params, limit: '500' }; + + while (true) { + const p: Record<string, string> = { ...baseParams }; + if (cursor) p.cursor = cursor; + const page = await fetchJson<CursorPaginated<T>>(url, { params: p, signal }); + all.push(...page.items); + if (onProgress) onProgress(all.length); + if (!page.cursor.next) break; + cursor = page.cursor.next; + } + return all; +} + +export function apiUrl(ts: string, path: string): string { + return `${apiBase}/api/v5/${encodeURIComponent(ts)}/${path}`; +} + +export interface CursorPageResult<T> { + items: T[]; + nextCursor: string | null; +} + +/** + * Fetch exactly one page of cursor-paginated results. + * Unlike fetchAllCursorPages, the caller controls limit and cursor via params. + */ +export async function fetchOneCursorPage<T>( + url: string, + params?: Record<string, string>, + signal?: AbortSignal, +): Promise<CursorPageResult<T>> { + const page = await fetchJson<CursorPaginated<T>>(url, { params, signal }); + return { items: page.items, nextCursor: page.cursor.next }; +} + +export async function getFields(ts: string, signal?: AbortSignal): Promise<FieldInfo[]> { + const data = await fetchJson<{ schema: { metrics: FieldInfo[] } }>( + `${apiBase}/api/v5/test-suites/${encodeURIComponent(ts)}`, + { signal }, + ); + return data.schema.metrics; +} + +export async function getOrders( + ts: string, + signal?: AbortSignal, + onProgress?: (loaded: number) => void, +): Promise<OrderSummary[]> { + return fetchAllCursorPages<OrderSummary>(apiUrl(ts, 'orders'), undefined, signal, onProgress); +} + +export async function getMachines( + ts: string, + opts: { namePrefix?: string; nameContains?: string; limit?: number; offset?: number }, + signal?: AbortSignal, +): Promise<{ items: MachineInfo[]; total: number }> { + const params: Record<string, string> = {}; + if (opts.namePrefix) params.name_prefix = opts.namePrefix; + if (opts.nameContains) params.name_contains = opts.nameContains; + if (opts.limit !== undefined) params.limit = String(opts.limit); + if (opts.offset !== undefined) params.offset = String(opts.offset); + const data = await fetchJson<OffsetPaginated<MachineInfo>>(apiUrl(ts, 'machines'), { params, signal }); + return { items: data.items, total: data.total }; +} + +export async function getRuns( + ts: string, + opts: { machine: string; order?: string }, + signal?: AbortSignal, +): Promise<RunInfo[]> { + const params: Record<string, string> = { machine: opts.machine }; + if (opts.order) params.order = opts.order; + return fetchAllCursorPages<RunInfo>( + apiUrl(ts, 'runs'), + params, + signal, + ); +} + +export async function getSamples( + ts: string, + runUuid: string, + signal?: AbortSignal, + onProgress?: (loaded: number) => void, +): Promise<SampleInfo[]> { + return fetchAllCursorPages<SampleInfo>( + apiUrl(ts, `runs/${encodeURIComponent(runUuid)}/samples`), + undefined, + signal, + onProgress, + ); +} + +export async function getMachine( + ts: string, + name: string, + signal?: AbortSignal, +): Promise<MachineInfo> { + return fetchJson<MachineInfo>( + apiUrl(ts, `machines/${encodeURIComponent(name)}`), + { signal }, + ); +} + +export async function getMachineRuns( + ts: string, + machineName: string, + opts?: { sort?: string; limit?: number; cursor?: string }, + signal?: AbortSignal, +): Promise<CursorPaginated<MachineRunInfo>> { + const params: Record<string, string> = {}; + if (opts?.sort) params.sort = opts.sort; + if (opts?.limit !== undefined) params.limit = String(opts.limit); + if (opts?.cursor) params.cursor = opts.cursor; + return fetchJson<CursorPaginated<MachineRunInfo>>( + apiUrl(ts, `machines/${encodeURIComponent(machineName)}/runs`), + { params, signal }, + ); +} + +export async function deleteMachine(ts: string, name: string): Promise<void> { + return fetchVoid(apiUrl(ts, `machines/${encodeURIComponent(name)}`), { method: 'DELETE' }); +} + +export async function getRun( + ts: string, + uuid: string, + signal?: AbortSignal, +): Promise<RunDetail> { + return fetchJson<RunDetail>( + apiUrl(ts, `runs/${encodeURIComponent(uuid)}`), + { signal }, + ); +} + +export async function deleteRun(ts: string, uuid: string): Promise<void> { + return fetchVoid(apiUrl(ts, `runs/${encodeURIComponent(uuid)}`), { method: 'DELETE' }); +} + +export async function getOrder( + ts: string, + value: string, + signal?: AbortSignal, +): Promise<OrderDetail> { + return fetchJson<OrderDetail>( + apiUrl(ts, `orders/${encodeURIComponent(value)}`), + { signal }, + ); +} + +export async function getRunsByOrder( + ts: string, + orderValue: string, + signal?: AbortSignal, +): Promise<RunInfo[]> { + return fetchAllCursorPages<RunInfo>( + apiUrl(ts, 'runs'), + { order: orderValue }, + signal, + ); +} + +export async function getRecentRuns( + ts: string, + opts?: { limit?: number; sort?: string }, + signal?: AbortSignal, +): Promise<CursorPaginated<RunInfo>> { + const params: Record<string, string> = {}; + if (opts?.limit !== undefined) params.limit = String(opts.limit); + if (opts?.sort) params.sort = opts.sort; + return fetchJson<CursorPaginated<RunInfo>>( + apiUrl(ts, 'runs'), + { params, signal }, + ); +} + +export async function getFieldChanges( + ts: string, + opts?: { limit?: number; cursor?: string }, + signal?: AbortSignal, +): Promise<CursorPaginated<FieldChangeInfo>> { + const params: Record<string, string> = {}; + if (opts?.limit !== undefined) params.limit = String(opts.limit); + if (opts?.cursor) params.cursor = opts.cursor; + return fetchJson<CursorPaginated<FieldChangeInfo>>( + apiUrl(ts, 'field-changes'), + { params, signal }, + ); +} + +export async function searchOrdersByTag( + ts: string, + tagPrefix: string, + opts?: { limit?: number }, + signal?: AbortSignal, +): Promise<CursorPaginated<OrderSummary>> { + const params: Record<string, string> = { tag_prefix: tagPrefix }; + if (opts?.limit !== undefined) params.limit = String(opts.limit); + return fetchJson<CursorPaginated<OrderSummary>>( + apiUrl(ts, 'orders'), + { params, signal }, + ); +} + +export async function updateOrderTag( + ts: string, + orderValue: string, + tag: string | null, + signal?: AbortSignal, +): Promise<OrderDetail> { + return fetchJson<OrderDetail>( + apiUrl(ts, `orders/${encodeURIComponent(orderValue)}`), + { method: 'PATCH', body: { tag }, signal }, + ); +} + +export async function queryDataPoints( + ts: string, + opts: { + machine?: string; + metric?: string; + test?: string; + afterOrder?: string; + beforeOrder?: string; + sort?: string; + }, + signal?: AbortSignal, + onProgress?: (loaded: number) => void, +): Promise<QueryDataPoint[]> { + const params: Record<string, string> = {}; + if (opts.machine) params.machine = opts.machine; + if (opts.metric) params.metric = opts.metric; + if (opts.test) params.test = opts.test; + if (opts.afterOrder) params.after_order = opts.afterOrder; + if (opts.beforeOrder) params.before_order = opts.beforeOrder; + if (opts.sort) params.sort = opts.sort; + return fetchAllCursorPages<QueryDataPoint>( + apiUrl(ts, 'query'), + params, + signal, + onProgress, + ); +} + +// --------------------------------------------------------------------------- +// Test suite info +// --------------------------------------------------------------------------- + +export async function getTestSuiteInfo( + ts: string, + signal?: AbortSignal, +): Promise<TestSuiteInfo> { + return fetchJson<TestSuiteInfo>( + `${apiBase}/api/v5/test-suites/${encodeURIComponent(ts)}`, + { signal }, + ); +} + +export async function createTestSuite( + payload: Record<string, unknown>, + signal?: AbortSignal, +): Promise<TestSuiteInfo> { + return fetchJson<TestSuiteInfo>( + `${apiBase}/api/v5/test-suites/`, + { method: 'POST', body: payload, signal }, + ); +} + +export async function deleteTestSuite( + name: string, + signal?: AbortSignal, +): Promise<void> { + return fetchVoid( + `${apiBase}/api/v5/test-suites/${encodeURIComponent(name)}?confirm=true`, + { method: 'DELETE', signal }, + ); +} + +// --------------------------------------------------------------------------- +// Admin — API keys (requires admin-scoped token) +// --------------------------------------------------------------------------- + +export async function getApiKeys(signal?: AbortSignal): Promise<APIKeyItem[]> { + const data = await fetchJson<{ items: APIKeyItem[] }>( + `${apiBase}/api/v5/admin/api-keys`, + { signal }, + ); + return data.items; +} + +export async function createApiKey( + name: string, + scope: string, + signal?: AbortSignal, +): Promise<APIKeyCreateResponse> { + return fetchJson<APIKeyCreateResponse>( + `${apiBase}/api/v5/admin/api-keys`, + { method: 'POST', body: { name, scope }, signal }, + ); +} + +export async function revokeApiKey( + prefix: string, + signal?: AbortSignal, +): Promise<void> { + return fetchVoid( + `${apiBase}/api/v5/admin/api-keys/${encodeURIComponent(prefix)}`, + { method: 'DELETE', signal }, + ); +} diff --git a/lnt/server/ui/v5/frontend/src/chart.ts b/lnt/server/ui/v5/frontend/src/chart.ts new file mode 100644 index 000000000..81ff4458c --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/chart.ts @@ -0,0 +1,277 @@ +import type { ComparisonRow } from './types'; +import { CHART_ZOOM, CHART_HOVER } from './events'; +import { getState } from './state'; +import { el } from './utils'; + +export interface ChartData { + sortedTests: string[]; + x: number[]; + y: number[]; + colors: string[]; + customdata: string[][]; +} + +/** + * Prepare chart data from comparison rows. + * Filters, sorts, and maps rows into Plotly-ready arrays. + * Returns null if no plottable data remains after filtering. + */ +export function prepareChartData( + rows: ComparisonRow[], + filterTests: Set<string> | null, +): ChartData | null { + // Filter to plottable rows + let plottable = rows.filter(r => + r.sidePresent === 'both' && r.ratio !== null && r.status !== 'na' + ); + + if (filterTests) { + plottable = plottable.filter(r => filterTests.has(r.test)); + } + + if (plottable.length === 0) { + return null; + } + + // Sort by ratio ascending + plottable.sort((a, b) => (a.ratio ?? 0) - (b.ratio ?? 0)); + const sortedTests = plottable.map(r => r.test); + + const x = plottable.map((_, i) => i); + const y = plottable.map(r => (r.ratio! - 1) * 100); // percent change from unity + + // Colors by status + const colors = plottable.map(r => { + switch (r.status) { + case 'improved': return '#2ca02c'; + case 'regressed': return '#d62728'; + case 'noise': return '#999999'; + default: return '#1f77b4'; + } + }); + + const customdata = plottable.map(r => [ + r.test, + r.valueA !== null ? r.valueA.toPrecision(4) : 'N/A', + r.valueB !== null ? r.valueB.toPrecision(4) : 'N/A', + r.deltaPct !== null ? `${r.deltaPct > 0 ? '+' : ''}${r.deltaPct.toFixed(2)}%` : 'N/A', + r.ratio !== null ? r.ratio.toFixed(4) : 'N/A', + ]); + + return { sortedTests, x, y, colors, customdata }; +} + +declare const Plotly: { + newPlot(el: HTMLElement, data: unknown[], layout: unknown, config?: unknown): Promise<HTMLElement>; + react(el: HTMLElement, data: unknown[], layout: unknown, config?: unknown): Promise<HTMLElement>; + purge(el: HTMLElement): void; + Fx: { + hover(el: HTMLElement, data: Array<{ curveNumber: number; pointNumber: number }>): void; + unhover(el: HTMLElement): void; + }; +}; + +let chartContainer: HTMLElement | null = null; +let chartData: ComparisonRow[] = []; +let sortedTests: string[] = []; // test names in chart order +let wiredContainer: HTMLElement | null = null; // track which container has listeners +/** Last zoom filter passed to drawChart, preserved for refreshChart(). */ +let lastFilterTests: Set<string> | null = null; + +export function renderChart(container: HTMLElement, rows: ComparisonRow[], preserveZoom = false): void { + // If switching to a different container, reset event wiring + if (chartContainer !== container) { + wiredContainer = null; + } + chartContainer = container; + chartData = rows; + drawChart(preserveZoom ? lastFilterTests : null); +} + +// Plotly event handlers — receive data directly via gd.on() API +function onPlotlyRelayout(data: Record<string, unknown>): void { + if (data && data['xaxis.range[0]'] !== undefined) { + const lo = Math.max(0, Math.floor(data['xaxis.range[0]'] as number)); + const hi = Math.min(sortedTests.length - 1, Math.ceil(data['xaxis.range[1]'] as number)); + const visibleTests = new Set(sortedTests.slice(lo, hi + 1)); + document.dispatchEvent(new CustomEvent(CHART_ZOOM, { detail: visibleTests })); + } else if (data && (data['xaxis.autorange'] || data['autosize'])) { + document.dispatchEvent(new CustomEvent(CHART_ZOOM, { detail: null })); + } +} + +function onPlotlyHover(data: { points?: Array<{ pointIndex: number }> }): void { + const points = data?.points; + if (points && points.length > 0) { + const testName = sortedTests[points[0].pointIndex]; + document.dispatchEvent(new CustomEvent(CHART_HOVER, { detail: testName })); + } +} + +function onPlotlyUnhover(): void { + document.dispatchEvent(new CustomEvent(CHART_HOVER, { detail: null })); +} + +function drawChart(filterTests: Set<string> | null): void { + if (!chartContainer) return; + lastFilterTests = filterTests; + + const state = getState(); + const noiseThreshold = state.noise; + + // Apply text filter from state on top of chart zoom filter + let effectiveFilter = filterTests; + if (state.testFilter) { + const lf = state.testFilter.toLowerCase(); + const textMatches = new Set<string>(); + for (const r of chartData) { + if (r.test.toLowerCase().includes(lf)) textMatches.add(r.test); + } + if (effectiveFilter) { + effectiveFilter = new Set([...effectiveFilter].filter(t => textMatches.has(t))); + } else { + effectiveFilter = textMatches; + } + } + + const prepared = prepareChartData(chartData, effectiveFilter); + + if (!prepared) { + Plotly.purge(chartContainer); + chartContainer.replaceChildren(el('p', { class: 'no-chart-data' }, 'No data to chart.')); + sortedTests = []; + wiredContainer = null; + return; + } + + sortedTests = prepared.sortedTests; + const { x, y, colors, customdata } = prepared; + + const trace = { + x, y, + customdata, + type: 'bar', + marker: { + color: colors, + line: { color: '#fff', width: 0.5 }, + }, + hovertemplate: + '<b>%{customdata[0]}</b><br>' + + 'Ratio: %{customdata[4]}<br>' + + 'Value A: %{customdata[1]}<br>' + + 'Value B: %{customdata[2]}<br>' + + 'Delta: %{customdata[3]}' + + '<extra></extra>', + }; + + // Noise band shapes + unity line (at y=0 = no change) + const shapes = [ + // Noise band lower + { + type: 'line' as const, + x0: -0.5, x1: sortedTests.length - 0.5, + y0: -noiseThreshold, y1: -noiseThreshold, + xref: 'x' as const, yref: 'y' as const, + line: { color: '#aaa', width: 1, dash: 'dash' as const }, + }, + // Noise band upper + { + type: 'line' as const, + x0: -0.5, x1: sortedTests.length - 0.5, + y0: noiseThreshold, y1: noiseThreshold, + xref: 'x' as const, yref: 'y' as const, + line: { color: '#aaa', width: 1, dash: 'dash' as const }, + }, + ]; + + const layout: Record<string, unknown> = { + xaxis: { + title: { text: 'Tests (sorted by ratio)' }, + showticklabels: false, + }, + yaxis: { + title: { text: 'Change from baseline (%)', standoff: 15 }, + ticksuffix: '%', + zeroline: true, + zerolinewidth: 2, + zerolinecolor: '#333', + }, + shapes, + bargap: 0, + margin: { t: 30, b: 50, l: 90, r: 20 }, + height: 400, + hovermode: 'closest', + dragmode: 'zoom', + }; + + // Preserve user zoom: read current axis ranges from the chart div + // (set by Plotly on user drag-zoom) and apply them to the new layout. + // If the user hasn't zoomed (autorange is true), don't set explicit + // ranges so Plotly auto-fits to new data. + if (wiredContainer === chartContainer) { + const gd = chartContainer as unknown as { layout?: Record<string, Record<string, unknown>> }; + if (gd.layout) { + const xa = gd.layout['xaxis']; + const ya = gd.layout['yaxis']; + if (xa && xa['autorange'] === false && xa['range']) { + (layout['xaxis'] as Record<string, unknown>)['range'] = xa['range']; + (layout['xaxis'] as Record<string, unknown>)['autorange'] = false; + } + if (ya && ya['autorange'] === false && ya['range']) { + (layout['yaxis'] as Record<string, unknown>)['range'] = ya['range']; + (layout['yaxis'] as Record<string, unknown>)['autorange'] = false; + } + } + } + + const config = { + responsive: true, + displayModeBar: true, + modeBarButtonsToRemove: ['toImage', 'sendDataToCloud'], + scrollZoom: true, + }; + + // If container was purged (no-data state), clear stale HTML before Plotly.react + if (wiredContainer !== chartContainer) { + chartContainer.replaceChildren(); + } + + Plotly.react(chartContainer, [trace], layout, config); + + // Wire events via Plotly's .on() API (added to the div by Plotly.react). + // Purge removes .on() handlers, so re-register whenever wiredContainer is stale. + if (wiredContainer !== chartContainer) { + const gd = chartContainer as unknown as { + on(event: string, handler: (...args: never[]) => void): void; + }; + gd.on('plotly_relayout', onPlotlyRelayout); + gd.on('plotly_hover', onPlotlyHover); + gd.on('plotly_unhover', onPlotlyUnhover); + wiredContainer = chartContainer; + } +} + +// External: highlight a point by test name +export function highlightPoint(testName: string | null): void { + if (!chartContainer) return; + if (!testName) { + try { Plotly.Fx.unhover(chartContainer); } catch { /* chart may be purged */ } + return; + } + const idx = sortedTests.indexOf(testName); + if (idx >= 0) { + Plotly.Fx.hover(chartContainer, [{ curveNumber: 0, pointNumber: idx }]); + } +} + +/** Purge the Plotly chart and reset module-level state. Call from page unmount. */ +export function destroyChart(): void { + if (chartContainer) { + Plotly.purge(chartContainer); + } + chartContainer = null; + chartData = []; + sortedTests = []; + wiredContainer = null; + lastFilterTests = null; +} diff --git a/lnt/server/ui/v5/frontend/src/combobox.ts b/lnt/server/ui/v5/frontend/src/combobox.ts new file mode 100644 index 000000000..470e61c92 --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/combobox.ts @@ -0,0 +1,324 @@ +import type { SideSelection } from './types'; +import { getMachines, getMachineRuns } from './api'; +import { debounce, el } from './utils'; + +// Per-side machine order filtering +let machineOrdersA: Set<string> | null = null; +let machineOrdersB: Set<string> | null = null; +let orderInputA: HTMLInputElement | null = null; +let orderInputB: HTMLInputElement | null = null; + +// Per-side AbortControllers for machine-order fetches +let machineOrdersControllerA: AbortController | null = null; +let machineOrdersControllerB: AbortController | null = null; +// Shared controller for machine name search (only one search active at a time) +let machineSearchController: AbortController | null = null; + +/** Shared state that the combobox module reads but does not own. */ +export interface ComboboxContext { + cachedOrderValues: string[]; + /** Map from order value to tag (null if no tag). */ + orderTags: Map<string, string | null>; + testsuite: string; + getSideState: (side: 'a' | 'b') => { + selection: SideSelection; + setSide: (partial: Partial<SideSelection>) => void; + label: string; + }; +} + +/** Reset per-panel mutable state. Call this at the start of renderSelectionPanel. */ +export function resetComboboxState(): void { + machineOrdersA = null; + machineOrdersB = null; + orderInputA = null; + orderInputB = null; + if (machineOrdersControllerA) { machineOrdersControllerA.abort(); machineOrdersControllerA = null; } + if (machineOrdersControllerB) { machineOrdersControllerB.abort(); machineOrdersControllerB = null; } + if (machineSearchController) { machineSearchController.abort(); machineSearchController = null; } +} + +async function fetchMachineOrders( + side: 'a' | 'b', + machine: string, + testsuite: string, +): Promise<void> { + // Abort any in-flight request for this side only + const prev = side === 'a' ? machineOrdersControllerA : machineOrdersControllerB; + if (prev) prev.abort(); + const ctrl = new AbortController(); + if (side === 'a') machineOrdersControllerA = ctrl; + else machineOrdersControllerB = ctrl; + + try { + // Fetch a single large page of machine runs instead of all pages. + // getMachineRuns returns lighter payloads (no machine/parameters fields) + // and a limit of 500 avoids unbounded pagination for machines with + // thousands of runs while still covering most real-world cases. + const page = await getMachineRuns(testsuite, machine, { limit: 500 }, ctrl.signal); + const orders = new Set<string>(); + for (const run of page.items) { + const keys = Object.keys(run.order); + if (keys.length > 0) { + orders.add(run.order[keys[0]]); + } + } + if (side === 'a') machineOrdersA = orders; + else machineOrdersB = orders; + } catch (err: unknown) { + // Silently ignore aborted requests — a newer one superseded this + if (err instanceof DOMException && err.name === 'AbortError') return; + // On other errors, don't filter orders + if (side === 'a') machineOrdersA = null; + else machineOrdersB = null; + } +} + +function setAriaExpanded(wrapper: HTMLElement, expanded: boolean): void { + wrapper.setAttribute('aria-expanded', String(expanded)); +} + +function setupComboboxKeyboard( + input: HTMLInputElement, + dropdown: HTMLUListElement, + wrapper: HTMLElement, +): void { + input.addEventListener('keydown', (e: KeyboardEvent) => { + if (e.key === 'ArrowDown') { + e.preventDefault(); + const first = dropdown.querySelector<HTMLLIElement>('li'); + if (first) first.focus(); + } else if (e.key === 'Escape') { + dropdown.classList.remove('open'); + setAriaExpanded(wrapper, false); + } + }); + + dropdown.addEventListener('keydown', (e: KeyboardEvent) => { + const target = e.target as HTMLElement; + if (target.tagName !== 'LI') return; + + if (e.key === 'ArrowDown') { + e.preventDefault(); + const next = target.nextElementSibling as HTMLElement | null; + if (next) next.focus(); + } else if (e.key === 'ArrowUp') { + e.preventDefault(); + const prev = target.previousElementSibling as HTMLElement | null; + if (prev) prev.focus(); + else input.focus(); + } else if (e.key === 'Enter') { + e.preventDefault(); + target.click(); + } else if (e.key === 'Escape') { + dropdown.classList.remove('open'); + setAriaExpanded(wrapper, false); + input.focus(); + } + }); +} + +export function createOrderCombobox( + side: 'a' | 'b', + setSide: (partial: Partial<SideSelection>) => void, + onOrderChange: () => void, + ctx: ComboboxContext, +): HTMLElement { + const dropdownId = `order-dropdown-${side}`; + const wrapper = el('div', { + class: 'combobox', + role: 'combobox', + 'aria-expanded': 'false', + 'aria-haspopup': 'listbox', + }); + const input = el('input', { + type: 'text', + placeholder: 'Type to search orders...', + class: 'combobox-input', + role: 'searchbox', + 'aria-autocomplete': 'list', + 'aria-controls': dropdownId, + }); + const dropdown = el('ul', { class: 'combobox-dropdown', role: 'listbox', id: dropdownId }); + wrapper.append(input, dropdown); + + // Prevent blur from firing when clicking a dropdown item + dropdown.addEventListener('mousedown', (e) => e.preventDefault()); + + // Keyboard navigation + setupComboboxKeyboard(input, dropdown, wrapper); + + // Store ref for external clearing + if (side === 'a') orderInputA = input; + else orderInputB = input; + + const { selection } = ctx.getSideState(side); + if (selection.order) { + const tag = ctx.orderTags.get(selection.order); + input.value = tag ? `${selection.order} (${tag})` : selection.order; + } + + function showDropdown(filter: string): void { + const machineOrders = side === 'a' ? machineOrdersA : machineOrdersB; + const { selection: sideState } = ctx.getSideState(side); + + // If a machine is selected but its orders haven't loaded yet, + // don't show unfiltered results — show a loading hint instead. + if (sideState.machine && !machineOrders) { + dropdown.replaceChildren( + el('li', { class: 'combobox-item', style: 'color: #999; pointer-events: none' }, 'Loading orders...'), + ); + dropdown.classList.add('open'); + setAriaExpanded(wrapper, true); + return; + } + + let source = ctx.cachedOrderValues; + if (machineOrders) { + source = source.filter(v => machineOrders.has(v)); + } + const lf = filter.toLowerCase(); + const matches = filter + ? source.filter(v => { + if (v.toLowerCase().includes(lf)) return true; + const tag = ctx.orderTags.get(v); + return tag !== null && tag !== undefined && tag.toLowerCase().includes(lf); + }) + : source; + const limited = matches.slice(0, 100); + + dropdown.replaceChildren(); + for (const v of limited) { + const tag = ctx.orderTags.get(v); + const label = tag ? `${v} (${tag})` : v; + const li = el('li', { class: 'combobox-item', role: 'option', tabindex: '-1' }, label); + li.addEventListener('click', () => { + input.value = label; + dropdown.classList.remove('open'); + setAriaExpanded(wrapper, false); + setSide({ order: v }); + onOrderChange(); + }); + dropdown.append(li); + } + const isOpen = limited.length > 0; + dropdown.classList.toggle('open', isOpen); + setAriaExpanded(wrapper, isOpen); + } + + input.addEventListener('focus', () => showDropdown(input.value)); + input.addEventListener('input', () => showDropdown(input.value)); + input.addEventListener('blur', () => { + dropdown.classList.remove('open'); + setAriaExpanded(wrapper, false); + }); + input.addEventListener('change', () => { + // Strip tag suffix if present (e.g., "abc123 (release-1)" → "abc123") + const raw = input.value.replace(/\s*\(.*\)$/, ''); + setSide({ order: raw }); + onOrderChange(); + }); + + return wrapper; +} + +export function createMachineCombobox( + side: 'a' | 'b', + setSide: (partial: Partial<SideSelection>) => void, + onMachineChange: () => void, + ctx: ComboboxContext, +): HTMLElement { + const dropdownId = `machine-dropdown-${side}`; + const wrapper = el('div', { + class: 'combobox', + role: 'combobox', + 'aria-expanded': 'false', + 'aria-haspopup': 'listbox', + }); + const input = el('input', { + type: 'text', + placeholder: 'Type to search machines...', + class: 'combobox-input', + role: 'searchbox', + 'aria-autocomplete': 'list', + 'aria-controls': dropdownId, + }); + const dropdown = el('ul', { class: 'combobox-dropdown', role: 'listbox', id: dropdownId }); + wrapper.append(input, dropdown); + + // Prevent blur from firing when clicking a dropdown item + dropdown.addEventListener('mousedown', (e) => e.preventDefault()); + + // Keyboard navigation + setupComboboxKeyboard(input, dropdown, wrapper); + + const { selection } = ctx.getSideState(side); + if (selection.machine) { + input.value = selection.machine; + // Pre-fetch orders for URL-restored machine so the order dropdown + // is correctly filtered from the start (not showing all orders). + fetchMachineOrders(side, selection.machine, ctx.testsuite); + } + + async function onMachineSelect(name: string): Promise<void> { + setSide({ machine: name }); + await fetchMachineOrders(side, name, ctx.testsuite); + // Clear order if it's no longer valid for this machine + const machineOrders = side === 'a' ? machineOrdersA : machineOrdersB; + const { selection: current } = ctx.getSideState(side); + if (machineOrders && current.order && !machineOrders.has(current.order)) { + setSide({ order: '' }); + } + const orderInput = side === 'a' ? orderInputA : orderInputB; + if (orderInput) { + const { selection: updated } = ctx.getSideState(side); + orderInput.value = updated.order || ''; + } + onMachineChange(); + } + + const doSearch = debounce(async () => { + // Abort any in-flight machine search request + if (machineSearchController) machineSearchController.abort(); + machineSearchController = new AbortController(); + const { signal } = machineSearchController; + + const prefix = input.value; + try { + const result = await getMachines(ctx.testsuite, { + namePrefix: prefix || undefined, + limit: 20, + }, signal); + dropdown.replaceChildren(); + for (const m of result.items) { + const li = el('li', { class: 'combobox-item', role: 'option', tabindex: '-1' }, m.name); + li.addEventListener('click', () => { + input.value = m.name; + dropdown.classList.remove('open'); + setAriaExpanded(wrapper, false); + onMachineSelect(m.name); + }); + dropdown.append(li); + } + const isOpen = result.items.length > 0; + dropdown.classList.toggle('open', isOpen); + setAriaExpanded(wrapper, isOpen); + } catch (err: unknown) { + // Silently ignore aborted requests — a newer one superseded this + if (err instanceof DOMException && err.name === 'AbortError') return; + // Ignore other errors during typeahead + } + }, 300); + + input.addEventListener('focus', () => doSearch()); + input.addEventListener('input', () => doSearch()); + input.addEventListener('blur', () => { + dropdown.classList.remove('open'); + setAriaExpanded(wrapper, false); + }); + input.addEventListener('change', () => { + onMachineSelect(input.value); + }); + + return wrapper; +} diff --git a/lnt/server/ui/v5/frontend/src/comparison.ts b/lnt/server/ui/v5/frontend/src/comparison.ts new file mode 100644 index 000000000..46326588e --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/comparison.ts @@ -0,0 +1,182 @@ +import type { AggFn, ComparisonRow, RowStatus, SampleInfo } from './types'; +import { getAggFn } from './utils'; + +/** + * Aggregate multiple samples within a single run for one metric. + * Groups by test name, applies aggFn to metric values (skips nulls). + */ +export function aggregateSamplesWithinRun( + samples: SampleInfo[], + metric: string, + aggFn: AggFn, +): Map<string, number> { + const byTest = new Map<string, number[]>(); + + for (const s of samples) { + const val = s.metrics[metric]; + if (val === null || val === undefined) continue; + let arr = byTest.get(s.test); + if (!arr) { + arr = []; + byTest.set(s.test, arr); + } + arr.push(val); + } + + const agg = getAggFn(aggFn); + const result = new Map<string, number>(); + for (const [test, values] of byTest) { + if (values.length > 0) { + result.set(test, agg(values)); + } + } + return result; +} + +/** + * Aggregate across multiple runs. For each test, collect the per-run values + * and apply aggFn. + */ +export function aggregateAcrossRuns( + perRunMaps: Map<string, number>[], + aggFn: AggFn, +): Map<string, number> { + if (perRunMaps.length === 0) return new Map(); + if (perRunMaps.length === 1) return perRunMaps[0]; + + const allTests = new Set<string>(); + for (const m of perRunMaps) { + for (const t of m.keys()) allTests.add(t); + } + + const agg = getAggFn(aggFn); + const result = new Map<string, number>(); + for (const test of allTests) { + const values: number[] = []; + for (const m of perRunMaps) { + const v = m.get(test); + if (v !== undefined) values.push(v); + } + if (values.length > 0) { + result.set(test, agg(values)); + } + } + return result; +} + +/** + * Full outer join on test name. Compute delta, deltaPct, ratio, status. + */ +export function computeComparison( + mapA: Map<string, number>, + mapB: Map<string, number>, + biggerIsBetter: boolean, + noiseThreshold: number, +): ComparisonRow[] { + const allTests = new Set<string>(); + for (const t of mapA.keys()) allTests.add(t); + for (const t of mapB.keys()) allTests.add(t); + + const rows: ComparisonRow[] = []; + + for (const test of allTests) { + const vA = mapA.get(test) ?? null; + const vB = mapB.get(test) ?? null; + + let sidePresent: 'both' | 'a_only' | 'b_only'; + if (vA !== null && vB !== null) sidePresent = 'both'; + else if (vA !== null) sidePresent = 'a_only'; + else sidePresent = 'b_only'; + + // Missing side + if (sidePresent !== 'both') { + rows.push({ + test, valueA: vA, valueB: vB, + delta: null, deltaPct: null, ratio: null, + status: 'missing', sidePresent, + }); + continue; + } + + // Both sides present + const delta = vB! - vA!; + + // Zero baseline + if (vA === 0) { + rows.push({ + test, valueA: vA, valueB: vB, + delta, deltaPct: null, ratio: null, + status: 'na', sidePresent, + }); + continue; + } + + // We use Math.abs(vA) in the denominator so that deltaPct always has the + // same sign as delta (positive when B > A, negative when B < A), even if + // the baseline is negative. Without abs, a negative baseline would flip + // the percentage sign, making the displayed value misleading. + const deltaPct = (delta / Math.abs(vA!)) * 100; + const ratio = vB! / vA!; + + let status: RowStatus; + if (Math.abs(deltaPct) <= noiseThreshold) { + status = 'noise'; + } else if (biggerIsBetter) { + status = delta > 0 ? 'improved' : 'regressed'; + } else { + status = delta < 0 ? 'improved' : 'regressed'; + } + + rows.push({ + test, valueA: vA, valueB: vB, + delta, deltaPct, ratio, + status, sidePresent, + }); + } + + return rows; +} + +export interface GeomeanResult { + /** Geometric mean of side A values. */ + geomeanA: number; + /** Geometric mean of side B values. */ + geomeanB: number; + /** Delta: geomeanB - geomeanA. */ + delta: number; + /** Delta as percentage of geomeanA. Null if geomeanA is 0. */ + deltaPct: number | null; + /** Geometric mean of per-test ratios (B/A). */ + ratioGeomean: number; +} + +/** + * Compute geomean summary for all rows present on both sides. + * Returns null if no valid rows exist. + */ +export function computeGeomean(rows: ComparisonRow[]): GeomeanResult | null { + const valid = rows.filter( + r => r.sidePresent === 'both' + && r.ratio !== null + && r.status !== 'na' + && r.valueA !== null + && r.valueB !== null + && r.valueA !== 0 + && r.valueB !== 0, + ); + + if (valid.length === 0) return null; + + const logSumA = valid.reduce((s, r) => s + Math.log(Math.abs(r.valueA!)), 0); + const logSumB = valid.reduce((s, r) => s + Math.log(Math.abs(r.valueB!)), 0); + const logSumRatio = valid.reduce((s, r) => s + Math.log(Math.abs(r.ratio!)), 0); + + const geomeanA = Math.exp(logSumA / valid.length); + const geomeanB = Math.exp(logSumB / valid.length); + const delta = geomeanB - geomeanA; + // Use Math.abs so deltaPct sign matches delta sign (see computeComparison). + const deltaPct = geomeanA !== 0 ? (delta / Math.abs(geomeanA)) * 100 : null; + const ratioGeomean = Math.exp(logSumRatio / valid.length); + + return { geomeanA, geomeanB, delta, deltaPct, ratioGeomean }; +} diff --git a/lnt/server/ui/v5/frontend/src/components/data-table.ts b/lnt/server/ui/v5/frontend/src/components/data-table.ts new file mode 100644 index 000000000..7bc08603c --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/components/data-table.ts @@ -0,0 +1,144 @@ +// components/data-table.ts — Reusable sortable data table. + +import { el } from '../utils'; + +export interface Column<T> { + key: string; + label: string; + /** Custom cell content. Return a string or DOM node. */ + render?: (row: T) => string | Node; + /** Extract a sortable value. Defaults to render text content. */ + sortValue?: (row: T) => string | number | null; + /** CSS class for the cell (e.g. 'col-num'). */ + cellClass?: string; + /** Whether this column is sortable (default true). */ + sortable?: boolean; +} + +export interface DataTableOptions<T> { + columns: Column<T>[]; + rows: T[]; + sortKey?: string; + sortDir?: 'asc' | 'desc'; + onRowClick?: (row: T) => void; + rowClass?: (row: T) => string; + emptyMessage?: string; +} + +/** + * Render a sortable data table into the given container. + * Clicking a column header sorts by that column. + */ +export function renderDataTable<T>( + container: HTMLElement, + options: DataTableOptions<T>, +): void { + let currentSortKey = options.sortKey || ''; + let currentSortDir: 'asc' | 'desc' = options.sortDir || 'asc'; + let sortedRows = sortRows(options.rows, options.columns, currentSortKey, currentSortDir); + + const table = el('table', { class: 'comparison-table data-table' }); + const thead = el('thead', {}); + const headerRow = el('tr', {}); + thead.append(headerRow); + table.append(thead); + + const tbody = el('tbody', {}); + table.append(tbody); + + function rebuildHeader(): void { + headerRow.replaceChildren(); + for (const col of options.columns) { + const sortable = col.sortable !== false; + const th = el('th', { + class: sortable ? 'sortable' : '', + }, col.label); + if (col.cellClass) th.classList.add(col.cellClass); + if (sortable && col.key === currentSortKey) { + th.append(currentSortDir === 'asc' ? ' \u25B2' : ' \u25BC'); + } + if (sortable) { + th.addEventListener('click', () => { + if (currentSortKey === col.key) { + currentSortDir = currentSortDir === 'asc' ? 'desc' : 'asc'; + } else { + currentSortKey = col.key; + currentSortDir = 'asc'; + } + sortedRows = sortRows(options.rows, options.columns, currentSortKey, currentSortDir); + rebuildHeader(); + rebuildBody(); + }); + } + headerRow.append(th); + } + } + + function rebuildBody(): void { + tbody.replaceChildren(); + if (sortedRows.length === 0) { + const emptyRow = el('tr', {}); + const emptyCell = el('td', { + colspan: String(options.columns.length), + class: 'no-results', + }, options.emptyMessage || 'No data.'); + emptyRow.append(emptyCell); + tbody.append(emptyRow); + return; + } + for (const row of sortedRows) { + const tr = el('tr', {}); + if (options.rowClass) { + const cls = options.rowClass(row); + if (cls) tr.className = cls; + } + if (options.onRowClick) { + tr.style.cursor = 'pointer'; + const handler = options.onRowClick; + tr.addEventListener('click', () => handler(row)); + } + for (const col of options.columns) { + const td = el('td', {}); + if (col.cellClass) td.className = col.cellClass; + if (col.render) { + const content = col.render(row); + if (typeof content === 'string') { + td.textContent = content; + } else { + td.append(content); + } + } else { + td.textContent = String((row as Record<string, unknown>)[col.key] ?? ''); + } + tr.append(td); + } + tbody.append(tr); + } + } + + rebuildHeader(); + rebuildBody(); + container.append(table); +} + +function sortRows<T>( + rows: T[], + columns: Column<T>[], + sortKey: string, + sortDir: 'asc' | 'desc', +): T[] { + if (!sortKey) return [...rows]; + const col = columns.find(c => c.key === sortKey); + if (!col) return [...rows]; + + const sorted = [...rows].sort((a, b) => { + const va = col.sortValue ? col.sortValue(a) : (a as Record<string, unknown>)[sortKey]; + const vb = col.sortValue ? col.sortValue(b) : (b as Record<string, unknown>)[sortKey]; + if (va === null || va === undefined) return 1; + if (vb === null || vb === undefined) return -1; + if (typeof va === 'number' && typeof vb === 'number') return va - vb; + return String(va).localeCompare(String(vb)); + }); + if (sortDir === 'desc') sorted.reverse(); + return sorted; +} diff --git a/lnt/server/ui/v5/frontend/src/components/delete-confirm.ts b/lnt/server/ui/v5/frontend/src/components/delete-confirm.ts new file mode 100644 index 000000000..3417f5396 --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/components/delete-confirm.ts @@ -0,0 +1,91 @@ +// components/delete-confirm.ts — Reusable delete-with-confirmation UI pattern. + +import { el } from '../utils'; +import { authErrorMessage } from '../api'; + +export interface DeleteConfirmOptions { + /** Label for the initial delete button (e.g. "Delete Machine"). */ + label: string; + /** Prompt text shown in the confirmation area. */ + prompt: string; + /** The value the user must type to enable the confirm button. */ + confirmValue: string; + /** Placeholder text for the confirmation input. */ + placeholder?: string; + /** Optional message shown while the deletion is in progress. */ + deletingMessage?: string; + /** Async function that performs the actual deletion. */ + onDelete: () => Promise<void>; + /** Called after successful deletion (e.g. to navigate away). */ + onSuccess: () => void; +} + +/** + * Render a delete button with a type-to-confirm safeguard. + * + * Clicking the button reveals a confirmation area where the user must type + * a specific value before the confirm button becomes enabled. + */ +export function renderDeleteConfirm( + container: HTMLElement, + options: DeleteConfirmOptions, +): void { + const deleteBtn = el('button', { class: 'admin-btn admin-btn-danger' }, options.label); + + const confirmDiv = el('div', { class: 'delete-machine-confirm' }); + confirmDiv.style.display = 'none'; + + const errorDiv = el('div', {}); + + deleteBtn.addEventListener('click', () => { + deleteBtn.style.display = 'none'; + confirmDiv.style.display = ''; + }); + + const prompt = el('p', {}, options.prompt); + const confirmInput = el('input', { + type: 'text', + class: 'admin-input', + placeholder: options.placeholder ?? '', + }) as HTMLInputElement; + const confirmBtn = el('button', { class: 'admin-btn admin-btn-danger', disabled: '' }, 'Confirm Delete') as HTMLButtonElement; + const cancelBtn = el('button', { class: 'admin-btn' }, 'Cancel'); + + confirmInput.addEventListener('input', () => { + confirmBtn.disabled = confirmInput.value !== options.confirmValue; + }); + + cancelBtn.addEventListener('click', () => { + confirmDiv.style.display = 'none'; + confirmInput.value = ''; + confirmBtn.disabled = true; + deleteBtn.style.display = ''; + errorDiv.replaceChildren(); + }); + + confirmBtn.addEventListener('click', () => { + confirmBtn.disabled = true; + confirmBtn.textContent = 'Deleting...'; + if (options.deletingMessage) { + errorDiv.replaceChildren( + el('p', { class: 'progress-label' }, options.deletingMessage), + ); + } else { + errorDiv.replaceChildren(); + } + + options.onDelete() + .then(() => { + options.onSuccess(); + }) + .catch((err: unknown) => { + confirmBtn.disabled = false; + confirmBtn.textContent = 'Confirm Delete'; + errorDiv.replaceChildren(el('p', { class: 'error-banner' }, authErrorMessage(err))); + }); + }); + + const btnRow = el('div', { class: 'admin-form-row' }, confirmBtn, cancelBtn); + confirmDiv.append(prompt, confirmInput, btnRow); + container.append(deleteBtn, confirmDiv, errorDiv); +} diff --git a/lnt/server/ui/v5/frontend/src/components/legend-table.ts b/lnt/server/ui/v5/frontend/src/components/legend-table.ts new file mode 100644 index 000000000..8f784de5e --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/components/legend-table.ts @@ -0,0 +1,161 @@ +// components/legend-table.ts — Legend table below the graph chart. + +import { el, TRACE_SEP } from '../utils'; +import { GRAPH_TABLE_HOVER } from '../events'; + +export interface LegendEntry { + testName: string; + color: string; + active: boolean; + /** Machine name shown right-justified in the row. */ + machineName?: string; + /** Unicode character representing the marker symbol (e.g., '●', '▲'). */ + symbolChar?: string; +} + +export interface LegendTableOptions { + entries: LegendEntry[]; + onToggle: (testName: string) => void; + /** Called on double-click: isolate this test (or restore all if already isolated). */ + onIsolate: (testName: string) => void; + /** Optional message shown above the table rows (e.g., cap warning). */ + message?: string; +} + +export interface LegendTableHandle { + /** Re-render the table with new entries and optional message. */ + update(entries: LegendEntry[], message?: string): void; + /** Highlight (or un-highlight) a row by test name. */ + highlightRow(testName: string | null): void; + /** Remove the table and clean up listeners. */ + destroy(): void; +} + +/** + * Create a legend table listing all tests with color swatches. + * Active tests are listed first, then inactive tests (grayed out). + * Clicking a row calls onToggle. Hovering dispatches GRAPH_TABLE_HOVER. + */ +export function createLegendTable( + container: HTMLElement, + options: LegendTableOptions, +): LegendTableHandle { + const wrapper = el('div', {}); + const messageEl = el('div', { class: 'legend-message' }); + const table = el('table', { class: 'legend-table' }); + const tbody = el('tbody'); + table.append(tbody); + wrapper.append(messageEl, table); + container.append(wrapper); + + let currentOnToggle = options.onToggle; + let currentOnIsolate = options.onIsolate; + + function setMessage(msg?: string): void { + if (msg) { + messageEl.textContent = msg; + messageEl.style.display = ''; + } else { + messageEl.textContent = ''; + messageEl.style.display = 'none'; + } + } + + function buildRows(entries: LegendEntry[]): void { + tbody.replaceChildren(); + for (const entry of entries) { + const tr = el('tr', { 'data-test': entry.testName }); + if (!entry.active) tr.classList.add('legend-row-inactive'); + + // Colored symbol cell — symbol character rendered in the trace color + const symbolCell = el('td', { class: 'legend-swatch-cell' }); + const symbolChar = entry.symbolChar || '●'; + const symbolSpan = el('span', { class: 'legend-symbol' }, symbolChar); + (symbolSpan as HTMLElement).style.color = entry.color; + symbolCell.append(symbolSpan); + + // Test name (left-justified) — extract from trace name if machine is present + const displayTestName = entry.machineName + ? entry.testName.replace(`${TRACE_SEP}${entry.machineName}`, '') + : entry.testName; + const nameCell = el('td', { class: 'legend-test-name' }, displayTestName); + + // Machine name (right-justified) — always render cell for consistent column count + const machineCell = el('td', { class: 'legend-machine-name' }, entry.machineName ?? ''); + + tr.append(symbolCell, nameCell, machineCell); + + tbody.append(tr); + } + } + + buildRows(options.entries); + setMessage(options.message); + + // Click/dblclick delegation. + // Delay single-click to distinguish from double-click: a double-click + // fires two click events then a dblclick. We cancel the pending single- + // click when a dblclick arrives so the toggle doesn't fire spuriously. + let clickTimer: ReturnType<typeof setTimeout> | null = null; + + tbody.addEventListener('click', (e) => { + const tr = (e.target as HTMLElement).closest('tr[data-test]'); + if (!tr) return; + const testName = tr.getAttribute('data-test')!; + if (clickTimer) clearTimeout(clickTimer); + clickTimer = setTimeout(() => { + clickTimer = null; + currentOnToggle(testName); + }, 200); + }); + + tbody.addEventListener('dblclick', (e) => { + if (clickTimer) { clearTimeout(clickTimer); clickTimer = null; } + const tr = (e.target as HTMLElement).closest('tr[data-test]'); + if (tr) { + currentOnIsolate(tr.getAttribute('data-test')!); + } + }); + + // Hover delegation + tbody.addEventListener('mouseenter', (e) => { + const tr = (e.target as HTMLElement).closest('tr[data-test]'); + if (tr) { + document.dispatchEvent(new CustomEvent(GRAPH_TABLE_HOVER, { + detail: tr.getAttribute('data-test'), + })); + } + }, true); + + tbody.addEventListener('mouseleave', (e) => { + const tr = (e.target as HTMLElement).closest('tr[data-test]'); + if (tr) { + document.dispatchEvent(new CustomEvent(GRAPH_TABLE_HOVER, { + detail: null, + })); + } + }, true); + + return { + update(entries: LegendEntry[], message?: string): void { + buildRows(entries); + setMessage(message); + }, + + highlightRow(testName: string | null): void { + // Remove previous highlight + const prev = tbody.querySelectorAll('.row-highlighted'); + for (const el of prev) el.classList.remove('row-highlighted'); + + if (testName) { + const row = tbody.querySelector(`tr[data-test="${CSS.escape(testName)}"]`); + if (row) row.classList.add('row-highlighted'); + } + }, + + destroy(): void { + if (clickTimer) { clearTimeout(clickTimer); clickTimer = null; } + wrapper.remove(); + }, + }; +} diff --git a/lnt/server/ui/v5/frontend/src/components/machine-combobox.ts b/lnt/server/ui/v5/frontend/src/components/machine-combobox.ts new file mode 100644 index 000000000..25295f41b --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/components/machine-combobox.ts @@ -0,0 +1,158 @@ +// components/machine-combobox.ts — Standalone machine typeahead selector. + +import { el, debounce } from '../utils'; +import { getMachines } from '../api'; + +export interface MachineComboboxOptions { + testsuite: string; + initialValue?: string; + onSelect: (name: string) => void; +} + +let comboboxCounter = 0; + +function setAriaExpanded(wrapper: HTMLElement, expanded: boolean): void { + wrapper.setAttribute('aria-expanded', String(expanded)); +} + +/** + * Render a machine name combobox with typeahead search. + * Calls getMachines with namePrefix on each keystroke (debounced 300ms). + */ +export function renderMachineCombobox( + container: HTMLElement, + opts: MachineComboboxOptions, +): { destroy: () => void; getValue: () => string; clear: () => void } { + const dropdownId = `machine-combo-list-${++comboboxCounter}`; + const wrapper = el('div', { + class: 'combobox', + role: 'combobox', + 'aria-expanded': 'false', + 'aria-haspopup': 'listbox', + }); + const input = el('input', { + type: 'text', + class: 'combobox-input', + placeholder: 'Type to search machines...', + autocomplete: 'off', + role: 'searchbox', + 'aria-autocomplete': 'list', + 'aria-controls': dropdownId, + }) as HTMLInputElement; + if (opts.initialValue) input.value = opts.initialValue; + + const dropdown = el('ul', { class: 'combobox-dropdown', role: 'listbox', id: dropdownId }); + wrapper.append(input, dropdown); + container.append(wrapper); + + // Prevent dropdown clicks from blurring the input + dropdown.addEventListener('mousedown', (e) => e.preventDefault()); + + let abortCtrl: AbortController | null = null; + let selectedValue = opts.initialValue || ''; + + const doSearch = debounce(async () => { + const text = input.value.trim(); + if (abortCtrl) abortCtrl.abort(); + abortCtrl = new AbortController(); + try { + const result = await getMachines(opts.testsuite, { + namePrefix: text || undefined, limit: 20, + }, abortCtrl.signal); + dropdown.replaceChildren(); + if (result.items.length === 0) { + dropdown.classList.remove('open'); + setAriaExpanded(wrapper, false); + return; + } + for (const machine of result.items) { + const li = el('li', { class: 'combobox-item', tabindex: '-1' }, machine.name); + li.addEventListener('click', () => { + input.value = machine.name; + selectedValue = machine.name; + dropdown.classList.remove('open'); + setAriaExpanded(wrapper, false); + opts.onSelect(machine.name); + }); + dropdown.append(li); + } + dropdown.classList.add('open'); + setAriaExpanded(wrapper, true); + } catch (e: unknown) { + if (e instanceof DOMException && e.name === 'AbortError') return; + } + }, 300); + + input.addEventListener('input', doSearch as EventListener); + input.addEventListener('focus', () => { + if (!input.value.trim() && !dropdown.classList.contains('open')) { + doSearch(); + } + }); + + // Keyboard navigation + input.addEventListener('keydown', (e) => { + if (e.key === 'ArrowDown') { + e.preventDefault(); + const first = dropdown.querySelector<HTMLElement>('.combobox-item'); + if (first) first.focus(); + } else if (e.key === 'Enter') { + e.preventDefault(); + const text = input.value.trim(); + if (text) { + selectedValue = text; + dropdown.classList.remove('open'); + setAriaExpanded(wrapper, false); + opts.onSelect(text); + } + } else if (e.key === 'Escape') { + dropdown.classList.remove('open'); + setAriaExpanded(wrapper, false); + } + }); + + dropdown.addEventListener('keydown', (e) => { + const target = e.target as HTMLElement; + if (e.key === 'ArrowDown') { + e.preventDefault(); + const next = target.nextElementSibling as HTMLElement | null; + if (next) next.focus(); + } else if (e.key === 'ArrowUp') { + e.preventDefault(); + const prev = target.previousElementSibling as HTMLElement | null; + if (prev) prev.focus(); + else input.focus(); + } else if (e.key === 'Enter') { + e.preventDefault(); + target.click(); + } else if (e.key === 'Escape') { + dropdown.classList.remove('open'); + setAriaExpanded(wrapper, false); + input.focus(); + } + }); + + function onDocClick(e: MouseEvent): void { + if (!wrapper.contains(e.target as Node)) { + dropdown.classList.remove('open'); + setAriaExpanded(wrapper, false); + } + } + document.addEventListener('click', onDocClick); + + return { + destroy() { + document.removeEventListener('click', onDocClick); + if (abortCtrl) abortCtrl.abort(); + }, + getValue() { + return selectedValue; + }, + clear() { + input.value = ''; + selectedValue = ''; + dropdown.classList.remove('open'); + setAriaExpanded(wrapper, false); + }, + }; +} diff --git a/lnt/server/ui/v5/frontend/src/components/metric-selector.ts b/lnt/server/ui/v5/frontend/src/components/metric-selector.ts new file mode 100644 index 000000000..622e2337f --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/components/metric-selector.ts @@ -0,0 +1,49 @@ +// components/metric-selector.ts — Reusable metric drop-down. + +import { el } from '../utils'; +import type { FieldInfo } from '../types'; + +/** Filter fields to only plottable numeric metrics (type === 'Real'). */ +export function filterMetricFields(fields: FieldInfo[]): FieldInfo[] { + return fields.filter(f => f.type === 'Real'); +} + +export interface MetricSelectorOptions { + /** When true, prepend a "-- Select metric --" placeholder with empty value. */ + placeholder?: boolean; +} + +/** + * Create a metric selector dropdown from the given fields. + * Callers should pre-filter with filterMetricFields() if needed. + * If initialValue matches a field name, that option is pre-selected. + * Returns the effective initial metric name ('' when placeholder is active). + */ +export function renderMetricSelector( + container: HTMLElement, + fields: FieldInfo[], + onChange: (metric: string) => void, + initialValue?: string, + options?: MetricSelectorOptions, +): string { + if (fields.length === 0) return ''; + + const group = el('div', { class: 'control-group' }); + group.append(el('label', {}, 'Metric')); + const select = el('select', { class: 'metric-select' }) as HTMLSelectElement; + + if (options?.placeholder) { + select.append(el('option', { value: '' }, '-- Select metric --')); + } + + for (const f of fields) { + const opt = el('option', { value: f.name }, f.display_name || f.name); + if (initialValue && f.name === initialValue) (opt as HTMLOptionElement).selected = true; + select.append(opt); + } + select.addEventListener('change', () => onChange(select.value)); + group.append(select); + container.append(group); + + return select.value; +} diff --git a/lnt/server/ui/v5/frontend/src/components/nav.ts b/lnt/server/ui/v5/frontend/src/components/nav.ts new file mode 100644 index 000000000..dc20bbe6f --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/components/nav.ts @@ -0,0 +1,205 @@ +// components/nav.ts — Navigation bar for the v5 SPA. + +import { el } from '../utils'; +import { navigate } from '../router'; + +export interface NavConfig { + testsuite: string; + testsuites: string[]; + v4Url: string; + urlBase: string; // lnt_url_base +} + +let activeLink: HTMLElement | null = null; + +/** + * Render the navigation bar. + * Returns the nav element to prepend to the app root. + */ +export function renderNav(config: NavConfig): HTMLElement { + const nav = el('nav', { class: 'v5-nav' }); + + // Brand + const brand = el('a', { class: 'v5-nav-brand', href: '#' }, 'LNT'); + brand.addEventListener('click', (e) => { + e.preventDefault(); + navigate('/'); + }); + nav.append(brand); + + // Test suite selector + const suiteSelect = el('select', { class: 'v5-nav-suite-select' }) as HTMLSelectElement; + for (const name of config.testsuites) { + const opt = el('option', { value: name }, name); + if (name === config.testsuite) { + (opt as HTMLOptionElement).selected = true; + } + suiteSelect.append(opt); + } + suiteSelect.addEventListener('change', () => { + const newSuite = suiteSelect.value; + window.location.href = `${config.urlBase}/v5/${encodeURIComponent(newSuite)}/`; + }); + const suiteGroup = el('div', { class: 'v5-nav-suite' }); + suiteGroup.append(el('span', {}, 'Suite: '), suiteSelect); + nav.append(suiteGroup); + nav.append(suiteGroup); + + // Navigation links + const links: { label: string; path: string }[] = [ + { label: 'Dashboard', path: '/' }, + { label: 'Graph', path: '/graph' }, + { label: 'Compare', path: '/compare' }, + { label: 'Regressions', path: '/regressions' }, + { label: 'Machines', path: '/machines' }, + ]; + + const linksContainer = el('div', { class: 'v5-nav-links' }); + for (const link of links) { + if (config.testsuite) { + // Normal testsuite context — use SPA navigation + const a = el('a', { + class: 'v5-nav-link', + href: '#', + 'data-path': link.path, + }, link.label); + a.addEventListener('click', (e) => { + e.preventDefault(); + navigate(link.path); + }); + linksContainer.append(a); + } else { + // Admin context (no testsuite) — use full page navigation + // to the suite selected in the dropdown + const a = el('a', { + class: 'v5-nav-link', + 'data-path': link.path, + }, link.label); + a.addEventListener('click', (e) => { + e.preventDefault(); + const suite = suiteSelect.value; + if (suite) { + window.location.href = `${config.urlBase}/v5/${encodeURIComponent(suite)}${link.path}`; + } + }); + linksContainer.append(a); + } + } + + // Admin link — goes to /v5/admin (outside testsuite namespace) + const adminLink = el('a', { + class: 'v5-nav-link', + href: `${config.urlBase}/v5/admin`, + 'data-path': '/admin', + }, 'Admin'); + linksContainer.append(adminLink); + + nav.append(linksContainer); + + // Right side: v4 toggle + Settings + const rightGroup = el('div', { class: 'v5-nav-right' }); + + const v4Link = el('a', { class: 'v5-nav-link', href: config.v4Url }, 'v4 UI'); + rightGroup.append(v4Link); + + const settingsLink = el('a', { + class: 'v5-nav-link', + href: '#', + }, 'Settings'); + settingsLink.addEventListener('click', (e) => { + e.preventDefault(); + toggleSettings(); + }); + rightGroup.append(settingsLink); + nav.append(rightGroup); + + return nav; +} + +/** + * Update the active link in the nav bar based on the current route. + * Call this after each route resolution. + */ +export function updateActiveNavLink(currentPath: string): void { + if (activeLink) { + activeLink.classList.remove('v5-nav-link-active'); + } + activeLink = null; + + const links = document.querySelectorAll<HTMLElement>('.v5-nav-link[data-path]'); + for (const link of links) { + const path = link.getAttribute('data-path'); + if (!path) continue; + + // Exact match for "/" (dashboard), prefix match for others + if (path === '/') { + if (currentPath === '/' || currentPath === '') { + link.classList.add('v5-nav-link-active'); + activeLink = link; + } + } else if (currentPath.startsWith(path)) { + link.classList.add('v5-nav-link-active'); + activeLink = link; + } + } +} + +/** + * Remove a suite from the nav bar dropdown (e.g. after deletion). + */ +export function removeSuiteFromNav(suiteName: string): void { + const select = document.querySelector('.v5-nav-suite-select') as HTMLSelectElement | null; + if (!select) return; + for (const opt of Array.from(select.options)) { + if (opt.value === suiteName) { + opt.remove(); + break; + } + } +} + +/** + * Add a suite to the nav bar dropdown in sorted position (e.g. after creation). + */ +export function addSuiteToNav(suiteName: string): void { + const select = document.querySelector('.v5-nav-suite-select') as HTMLSelectElement | null; + if (!select) return; + const options = Array.from(select.options); + // Avoid duplicates + if (options.some(o => o.value === suiteName)) return; + const insertIndex = options.findIndex(o => o.value > suiteName); + const opt = new Option(suiteName, suiteName); + if (insertIndex === -1) select.add(opt); + else select.add(opt, insertIndex); +} + +/** Settings panel toggle (token input). Reuses the existing pattern. */ +function toggleSettings(): void { + let panel = document.getElementById('v5-settings-panel'); + if (panel) { + panel.style.display = panel.style.display === 'none' ? 'block' : 'none'; + return; + } + + // Create settings panel + panel = el('div', { id: 'v5-settings-panel', class: 'settings-panel' }); + panel.append(el('label', {}, 'Auth Token')); + const tokenInput = el('input', { + type: 'password', + class: 'token-input', + placeholder: 'Paste v5 API token...', + }) as HTMLInputElement; + tokenInput.value = localStorage.getItem('lnt_v5_token') || ''; + tokenInput.addEventListener('change', () => { + const val = tokenInput.value.trim(); + if (val) localStorage.setItem('lnt_v5_token', val); + else localStorage.removeItem('lnt_v5_token'); + }); + panel.append(tokenInput); + + // Insert after the nav + const nav = document.querySelector('.v5-nav'); + if (nav && nav.parentElement) { + nav.parentElement.insertBefore(panel, nav.nextSibling); + } +} diff --git a/lnt/server/ui/v5/frontend/src/components/order-search.ts b/lnt/server/ui/v5/frontend/src/components/order-search.ts new file mode 100644 index 000000000..4103a7628 --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/components/order-search.ts @@ -0,0 +1,229 @@ +// components/order-search.ts — Order search with tag-based autocomplete. + +import { el, debounce, primaryOrderValue } from '../utils'; +import { searchOrdersByTag } from '../api'; +import { navigate } from '../router'; + +export interface OrderSuggestion { + orderValue: string; + tag: string | null; +} + +export interface OrderSearchOptions { + testsuite: string; + placeholder?: string; + /** If provided, called instead of navigating to Order Detail. */ + onSelect?: (orderValue: string) => void; + /** Pre-loaded suggestions shown on focus. Tagged orders should come first. */ + suggestions?: OrderSuggestion[]; +} + +let orderSearchCounter = 0; + +/** + * Render an order search input with autocomplete dropdown. + * + * - If suggestions are provided, shows them on focus (filtered by input text) + * - Otherwise, typing triggers a debounced tag_prefix search via the API + * - Enter selects the current input value directly + * - Clicking a dropdown item selects that order + */ +export function renderOrderSearch( + container: HTMLElement, + options: OrderSearchOptions, +): { destroy: () => void; setSuggestions: (s: OrderSuggestion[]) => void } { + const dropdownId = `order-search-list-${++orderSearchCounter}`; + const wrapper = el('div', { + class: 'order-search', + role: 'combobox', + 'aria-expanded': 'false', + 'aria-haspopup': 'listbox', + }); + const input = el('input', { + type: 'text', + class: 'order-search-input combobox-input', + placeholder: options.placeholder || 'Search by order value or tag...', + role: 'searchbox', + 'aria-autocomplete': 'list', + 'aria-controls': dropdownId, + }) as HTMLInputElement; + const dropdown = el('ul', { class: 'order-search-dropdown combobox-dropdown', role: 'listbox', id: dropdownId }); + wrapper.append(input, dropdown); + container.append(wrapper); + + // Prevent dropdown clicks from blurring the input + dropdown.addEventListener('mousedown', (e) => e.preventDefault()); + + let abortCtrl: AbortController | null = null; + let suggestions: OrderSuggestion[] = options.suggestions || []; + // When suggestions are explicitly provided (even as []), use suggestions mode: + // only show from the suggestions list, never fall back to API search. + const useSuggestionsMode = options.suggestions !== undefined; + + function selectOrder(value: string): void { + input.value = ''; + dropdown.classList.remove('open'); + wrapper.setAttribute('aria-expanded', 'false'); + if (options.onSelect) { + options.onSelect(value); + } else { + navigate(`/orders/${encodeURIComponent(value)}`); + } + } + + function showSuggestions(): void { + const text = input.value.trim().toLowerCase(); + const filtered = text + ? suggestions.filter(s => + s.orderValue.toLowerCase().startsWith(text) || + (s.tag && s.tag.toLowerCase().startsWith(text))) + : suggestions; + + dropdown.replaceChildren(); + if (filtered.length === 0) { + dropdown.classList.remove('open'); + wrapper.setAttribute('aria-expanded', 'false'); + return; + } + for (const s of filtered) { + const li = el('li', { class: 'combobox-item', tabindex: '-1' }); + li.append(el('span', {}, s.orderValue)); + if (s.tag) { + li.append(el('span', { class: 'order-search-tag' }, ` (${s.tag})`)); + } + li.addEventListener('click', () => selectOrder(s.orderValue)); + dropdown.append(li); + } + dropdown.classList.add('open'); + wrapper.setAttribute('aria-expanded', 'true'); + } + + // API-based search (fallback when no suggestions) + const doApiSearch = debounce(async () => { + const text = input.value.trim(); + if (!text) { + dropdown.classList.remove('open'); + wrapper.setAttribute('aria-expanded', 'false'); + return; + } + if (abortCtrl) abortCtrl.abort(); + abortCtrl = new AbortController(); + try { + const result = await searchOrdersByTag( + options.testsuite, text, { limit: 10 }, abortCtrl.signal, + ); + dropdown.replaceChildren(); + if (result.items.length === 0) { + dropdown.classList.remove('open'); + wrapper.setAttribute('aria-expanded', 'false'); + return; + } + for (const order of result.items) { + const pv = primaryOrderValue(order.fields); + const li = el('li', { class: 'combobox-item', tabindex: '-1' }); + li.append(el('span', {}, pv)); + if (order.tag) { + li.append(el('span', { class: 'order-search-tag' }, ` (${order.tag})`)); + } + li.addEventListener('click', () => selectOrder(pv)); + dropdown.append(li); + } + dropdown.classList.add('open'); + wrapper.setAttribute('aria-expanded', 'true'); + } catch (e: unknown) { + if (e instanceof DOMException && e.name === 'AbortError') return; + } + }, 300); + + function isValidOrder(value: string): boolean { + if (!useSuggestionsMode) return true; + return suggestions.some(s => s.orderValue === value); + } + + function updateValidationState(): void { + const text = input.value.trim(); + if (!text || !useSuggestionsMode) { + input.classList.remove('order-search-invalid'); + } else { + // Only show invalid when there are no partial matches (dropdown is empty) + const hasMatches = suggestions.some(s => + s.orderValue.toLowerCase().startsWith(text.toLowerCase()) || + (s.tag && s.tag.toLowerCase().startsWith(text.toLowerCase()))); + if (hasMatches) { + input.classList.remove('order-search-invalid'); + } else { + input.classList.add('order-search-invalid'); + } + } + } + + input.addEventListener('input', () => { + if (useSuggestionsMode) { + showSuggestions(); + updateValidationState(); + } else { + (doApiSearch as EventListener)(new Event('input')); + } + }); + + input.addEventListener('focus', () => { + if (useSuggestionsMode) { + showSuggestions(); + } + }); + + input.addEventListener('keydown', (e) => { + if (e.key === 'ArrowDown') { + e.preventDefault(); + const first = dropdown.querySelector<HTMLElement>('.combobox-item'); + if (first) first.focus(); + } else if (e.key === 'Enter') { + e.preventDefault(); + const text = input.value.trim(); + if (text && isValidOrder(text)) selectOrder(text); + } else if (e.key === 'Escape') { + dropdown.classList.remove('open'); + wrapper.setAttribute('aria-expanded', 'false'); + } + }); + + dropdown.addEventListener('keydown', (e) => { + const target = e.target as HTMLElement; + if (e.key === 'ArrowDown') { + e.preventDefault(); + const next = target.nextElementSibling as HTMLElement | null; + if (next) next.focus(); + } else if (e.key === 'ArrowUp') { + e.preventDefault(); + const prev = target.previousElementSibling as HTMLElement | null; + if (prev) prev.focus(); + else input.focus(); + } else if (e.key === 'Enter') { + e.preventDefault(); + target.click(); + } else if (e.key === 'Escape') { + dropdown.classList.remove('open'); + wrapper.setAttribute('aria-expanded', 'false'); + input.focus(); + } + }); + + // Close dropdown when clicking outside + function onDocClick(e: MouseEvent): void { + if (!wrapper.contains(e.target as Node)) { + dropdown.classList.remove('open'); + wrapper.setAttribute('aria-expanded', 'false'); + } + } + document.addEventListener('click', onDocClick); + + return { + destroy() { + document.removeEventListener('click', onDocClick); + if (abortCtrl) abortCtrl.abort(); + }, + setSuggestions(s: OrderSuggestion[]) { + suggestions = s; + }, + }; +} diff --git a/lnt/server/ui/v5/frontend/src/components/pagination.ts b/lnt/server/ui/v5/frontend/src/components/pagination.ts new file mode 100644 index 000000000..e5a81ad29 --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/components/pagination.ts @@ -0,0 +1,40 @@ +// components/pagination.ts — Previous/Next pagination controls. + +import { el } from '../utils'; + +export interface PaginationOptions { + hasPrevious: boolean; + hasNext: boolean; + onPrevious: () => void; + onNext: () => void; + rangeText?: string; +} + +/** + * Render pagination controls (Previous / Next buttons + optional range text). + */ +export function renderPagination( + container: HTMLElement, + options: PaginationOptions, +): void { + const row = el('div', { class: 'pagination-controls' }); + + const prevBtn = el('button', { + class: 'pagination-btn', + }, '\u2190 Previous') as HTMLButtonElement; + if (!options.hasPrevious) prevBtn.disabled = true; + prevBtn.addEventListener('click', options.onPrevious); + + const nextBtn = el('button', { + class: 'pagination-btn', + }, 'Next \u2192') as HTMLButtonElement; + if (!options.hasNext) nextBtn.disabled = true; + nextBtn.addEventListener('click', options.onNext); + + row.append(prevBtn); + if (options.rangeText) { + row.append(el('span', { class: 'pagination-range' }, options.rangeText)); + } + row.append(nextBtn); + container.append(row); +} diff --git a/lnt/server/ui/v5/frontend/src/components/time-series-chart.ts b/lnt/server/ui/v5/frontend/src/components/time-series-chart.ts new file mode 100644 index 000000000..7a99e185d --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/components/time-series-chart.ts @@ -0,0 +1,466 @@ +// components/time-series-chart.ts — Plotly time-series line chart. + +import { el, TRACE_SEP } from '../utils'; +import { GRAPH_CHART_HOVER } from '../events'; + +/** Escape HTML special characters to prevent XSS in Plotly hover templates. */ +function escapeHtml(s: string): string { + return s.replace(/&/g, '&').replace(/</g, '<').replace(/>/g, '>').replace(/"/g, '"'); +} + +declare const Plotly: { + newPlot(el: HTMLElement, data: unknown[], layout: unknown, config?: unknown): Promise<HTMLElement>; + react(el: HTMLElement, data: unknown[], layout: unknown, config?: unknown): Promise<HTMLElement>; + addTraces(el: HTMLElement, traces: unknown | unknown[], index?: number): void; + deleteTraces(el: HTMLElement, indices: number | number[]): void; + relayout(el: HTMLElement, update: Record<string, unknown>): void; + restyle(el: HTMLElement, update: Record<string, unknown>, traces?: number | number[]): void; + purge(el: HTMLElement): void; + Fx: { + hover(gd: HTMLElement, data: Array<{ curveNumber: number; pointNumber: number }>): void; + unhover(gd: HTMLElement): void; + }; +}; + +export interface TimeSeriesTrace { + testName: string; + /** Machine name for this trace. */ + machine: string; + /** Explicit color for the trace line and markers. */ + color?: string; + /** Plotly marker symbol (e.g., 'circle', 'triangle-up', 'square'). */ + markerSymbol?: string; + points: Array<{ + orderValue: string; + value: number; + runCount: number; + timestamp: string | null; + }>; +} + +export interface PinnedOrder { + orderValue: string; + tag: string | null; + /** Per-test values at this reference order. */ + values: Map<string, number>; + color: string; +} + +export interface TimeSeriesChartOptions { + traces: TimeSeriesTrace[]; + yAxisLabel: string; + pinnedOrders?: PinnedOrder[]; + onClick?: (orderValue: string) => void; + /** Fixed x-axis category order. When set, the x-axis shows exactly these + * categories in this order and does not resize as data loads progressively. */ + categoryOrder?: string[]; + /** Lazy callback to get individual pre-aggregation values for a data point. + * Called on hover; if it returns >1 values, a scatter of the raw values + * is shown at the hovered x-position. */ + getRawValues?: (testName: string, machine: string, orderValue: string) => number[]; +} + +/** + * Build Plotly trace objects and layout from our domain types. + * Exported for testing (data preparation logic). + */ +export function buildPlotlyData(options: TimeSeriesChartOptions): { + data: unknown[]; + layout: unknown; +} { + const data: unknown[] = []; + + // Collect all unique order values across all traces (for consistent x-axis) + const allOrders: string[] = []; + const orderSet = new Set<string>(); + for (const trace of options.traces) { + for (const pt of trace.points) { + if (!orderSet.has(pt.orderValue)) { + orderSet.add(pt.orderValue); + allOrders.push(pt.orderValue); + } + } + } + + for (const trace of options.traces) { + const x = trace.points.map(p => p.orderValue); + const y = trace.points.map(p => p.value); + const traceName = `${trace.testName}${TRACE_SEP}${trace.machine}`; + const customdata = trace.points.map(p => [ + p.orderValue, + traceName, + p.value.toPrecision(4), + String(p.runCount), + trace.testName, + trace.machine, + ]); + + const marker: Record<string, unknown> = { size: 4 }; + if (trace.color) marker.color = trace.color; + if (trace.markerSymbol) marker.symbol = trace.markerSymbol; + + const traceObj: Record<string, unknown> = { + x, + y, + name: traceName, + mode: 'lines+markers', + type: 'scatter', + marker, + line: { width: 1.5, ...(trace.color ? { color: trace.color } : {}) }, + customdata, + hovertemplate: + '<b>%{customdata[4]}</b><br>' + + 'Machine: %{customdata[5]}<br>' + + 'Order: %{customdata[0]}<br>' + + 'Value: %{customdata[2]}<br>' + + 'Runs: %{customdata[3]}<extra></extra>', + }; + + data.push(traceObj); + } + + // Reference order traces (horizontal dashed lines with hover tooltips). + // These are actual Plotly traces (not shapes) so they support hover. + // Each trace is populated with a data point at every x-category so that + // hover detection works anywhere along the line (not just at 2 endpoints). + if (options.pinnedOrders) { + const pinXValues = options.categoryOrder ?? (allOrders.length > 0 ? allOrders : null); + + if (pinXValues) { + for (const ref of options.pinnedOrders) { + const label = ref.tag ? `${ref.orderValue} (${ref.tag})` : ref.orderValue; + for (const [testName, value] of ref.values) { + const trace = options.traces.find(t => t.testName === testName); + if (!trace || trace.points.length === 0) continue; + + data.push({ + x: pinXValues, + y: Array(pinXValues.length).fill(value), + mode: 'lines', + type: 'scatter', + line: { color: ref.color, width: 1.5, dash: 'dot' }, + showlegend: false, + hovertemplate: + `<b>Pinned: ${escapeHtml(label)}</b><br>` + + `Test: ${escapeHtml(testName)}<br>` + + `Value: ${value.toPrecision(4)}<extra></extra>`, + }); + } + } + } + } + + const xaxis: Record<string, unknown> = { + type: 'category', + title: 'Order', + tickangle: -45, + automargin: true, + }; + if (options.categoryOrder) { + xaxis.categoryorder = 'array'; + xaxis.categoryarray = options.categoryOrder; + // Lock the visible range to show all categories — autorange ignores null + // y-values in the scaffold trace, so we must set the range explicitly. + xaxis.autorange = false; + xaxis.range = [-0.5, options.categoryOrder.length - 0.5]; + } + + // Overlay "No data to plot" when chart has a scaffold but no actual traces + const annotations: unknown[] = []; + if (options.traces.length === 0 && options.categoryOrder) { + annotations.push({ + text: 'No data to plot.', + xref: 'paper', + yref: 'paper', + x: 0.5, + y: 0.5, + showarrow: false, + font: { size: 16, color: '#999' }, + }); + } + + const layout = { + xaxis, + yaxis: { + title: options.yAxisLabel, + automargin: true, + }, + annotations, + margin: { t: 30, r: 20 }, + hovermode: 'closest' as const, + hoverdistance: 5, + showlegend: false, + autosize: true, + }; + + return { data, layout }; +} + +/** + * Handle returned by createTimeSeriesChart for incremental updates. + */ +export interface ChartHandle { + /** Update the chart with new options using Plotly.react() (preserves zoom/pan). */ + update(options: TimeSeriesChartOptions): void; + /** Programmatically highlight a trace by trace name '{test} · {machine}' (or clear highlight). */ + hoverTrace(traceName: string | null): void; + /** Destroy the chart and free resources. */ + destroy(): void; +} + +type PlotlyGd = HTMLElement & { + on: (evt: string, cb: (data: { points: Array<{ customdata?: string[]; curveNumber: number; pointNumber: number }> }) => void) => void; +}; + +/** + * Create a time-series chart that supports efficient incremental updates. + * First call uses Plotly.newPlot(); subsequent update() calls use Plotly.react(). + */ +export function createTimeSeriesChart( + container: HTMLElement, + options: TimeSeriesChartOptions, +): ChartHandle { + let chartDiv: HTMLElement | null = null; + let initialized = false; + let plotReady: Promise<void> = Promise.resolve(); + const config = { responsive: true, displayModeBar: true }; + /** Ordered list of main trace test names (excludes reference order traces). */ + let traceNames: string[] = []; + /** Total number of Plotly traces (main + reference order traces). */ + let totalTraceCount = 0; + /** Whether a temporary scatter trace is currently appended. */ + let hasScatterTrace = false; + /** Saved y-axis state before scatter trace was added (restored on unhover). */ + let savedYAxis: { range?: [number, number]; autorange?: unknown } | null = null; + /** Current getRawValues callback (updated on each doPlot). */ + let getRawValues: TimeSeriesChartOptions['getRawValues']; + /** Color map from test name to trace color (updated on each doPlot). */ + let traceColorMap = new Map<string, string>(); + + function attachHandlers(gd: PlotlyGd, opts: TimeSeriesChartOptions): void { + if (opts.onClick) { + const handler = opts.onClick; + gd.on('plotly_click', (eventData) => { + const pt = eventData.points[0]; + if (pt?.customdata?.[0]) { + handler(pt.customdata[0]); + } + }); + } + + // Dispatch hover events for bidirectional sync with legend table + // and show raw value scatter for aggregated points + gd.on('plotly_hover', (eventData) => { + const pt = eventData.points[0]; + const traceName = pt?.customdata?.[1]; + if (traceName) { + document.dispatchEvent(new CustomEvent(GRAPH_CHART_HOVER, { detail: traceName })); + } + + // Show raw value scatter if getRawValues is available + if (!getRawValues || !chartDiv) return; + const orderValue = pt?.customdata?.[0]; + const testName = pt?.customdata?.[4]; + const machineName = pt?.customdata?.[5]; + if (!testName || !machineName || !orderValue) return; + + // Remove any existing scatter trace first + plotReady = plotReady.then(() => { + if (!chartDiv) return; + if (hasScatterTrace) { + try { + Plotly.deleteTraces(chartDiv, [-1]); + if (savedYAxis) { + Plotly.relayout(chartDiv, { + 'yaxis.autorange': savedYAxis.autorange ?? true, + ...(savedYAxis.range ? { 'yaxis.range': savedYAxis.range } : {}), + }); + savedYAxis = null; + } + } catch { /* ok */ } + hasScatterTrace = false; + } + if (!getRawValues) return; + const rawValues = getRawValues(testName, machineName, orderValue); + if (rawValues.length <= 1) return; + + const color = traceColorMap.get(`${testName}${TRACE_SEP}${machineName}`) || '#999'; + const scatter = { + x: rawValues.map(() => orderValue), + y: rawValues, + mode: 'markers', + type: 'scatter', + marker: { size: 6, color, opacity: 0.3 }, + showlegend: false, + hoverinfo: 'skip' as const, + }; + try { + // Save y-axis state and lock range before adding scatter + const curLayout = (chartDiv as unknown as { layout?: { + yaxis?: { range?: [number, number]; autorange?: unknown }; + } }).layout; + if (curLayout?.yaxis) { + savedYAxis = { + range: curLayout.yaxis.range ? [...curLayout.yaxis.range] as [number, number] : undefined, + autorange: curLayout.yaxis.autorange, + }; + if (curLayout.yaxis.range) { + Plotly.relayout(chartDiv, { + 'yaxis.autorange': false, + 'yaxis.range': [...curLayout.yaxis.range], + }); + } + } + Plotly.addTraces(chartDiv, scatter); + hasScatterTrace = true; + } catch { /* ok */ } + }).catch(err => { + console.warn('Chart operation failed:', err); + }); + }); + gd.on('plotly_unhover', () => { + document.dispatchEvent(new CustomEvent(GRAPH_CHART_HOVER, { detail: null })); + + // Remove scatter trace and restore y-axis + if (hasScatterTrace && chartDiv) { + plotReady = plotReady.then(() => { + if (!chartDiv || !hasScatterTrace) return; + try { + Plotly.deleteTraces(chartDiv, [-1]); + if (savedYAxis) { + Plotly.relayout(chartDiv, { + 'yaxis.autorange': savedYAxis.autorange ?? true, + ...(savedYAxis.range ? { 'yaxis.range': savedYAxis.range } : {}), + }); + savedYAxis = null; + } + } catch { /* ok */ } + hasScatterTrace = false; + }).catch(err => { + console.warn('Chart operation failed:', err); + }); + } + }); + } + + function doPlot(opts: TimeSeriesChartOptions): void { + if (opts.traces.length === 0 && !opts.categoryOrder) { + if (chartDiv && initialized) { + try { Plotly.purge(chartDiv); } catch { /* ok */ } + } + container.replaceChildren(el('p', { class: 'no-chart-data' }, 'No data to plot.')); + chartDiv = null; + initialized = false; + traceNames = []; + plotReady = Promise.resolve(); + return; + } + + // Track main trace names for hoverTrace() mapping + traceNames = opts.traces.map(t => `${t.testName}${TRACE_SEP}${t.machine}`); + + // Update callback and color map for scatter-on-hover + getRawValues = opts.getRawValues; + traceColorMap = new Map<string, string>(); + for (const t of opts.traces) { + if (t.color) traceColorMap.set(`${t.testName}${TRACE_SEP}${t.machine}`, t.color); + } + + const { data, layout } = buildPlotlyData(opts); + + // Track total trace count (main + reference) for restyle operations + totalTraceCount = (data as unknown[]).length; + + // react()/newPlot() replaces all traces, so any scatter trace is gone + hasScatterTrace = false; + + if (initialized && chartDiv && chartDiv.parentElement) { + // Chain react() after any pending newPlot() to avoid race conditions + plotReady = plotReady.then(() => { + if (!chartDiv) return; + // Preserve current axis ranges so user zoom is not reset by the + // canonical layout from buildPlotlyData(). Read chartDiv.layout + // inside the .then() because it may not be populated until the + // previous newPlot()/react() resolves. + const cur = (chartDiv as unknown as { layout?: { + xaxis?: { range?: unknown; autorange?: unknown }; + yaxis?: { range?: unknown; autorange?: unknown }; + } }).layout; + const lx = layout as { xaxis?: Record<string, unknown>; yaxis?: Record<string, unknown> }; + if (cur?.xaxis && lx.xaxis) { + lx.xaxis.range = cur.xaxis.range; + lx.xaxis.autorange = cur.xaxis.autorange; + } + if (cur?.yaxis && cur.yaxis.autorange === false) { + // User has explicitly zoomed the y-axis — preserve their range. + if (lx.yaxis) { + lx.yaxis.range = cur.yaxis.range; + lx.yaxis.autorange = false; + } + } + Plotly.react(chartDiv, data, layout, config); + }).catch(err => { + console.warn('Chart operation failed:', err); + }); + } else { + chartDiv = el('div', { class: 'graph-chart' }); + container.replaceChildren(chartDiv); + initialized = true; + plotReady = Plotly.newPlot(chartDiv, data, layout, config).then((gd) => { + attachHandlers(gd as PlotlyGd, opts); + }).catch(err => { + console.warn('Chart operation failed:', err); + }); + } + } + + doPlot(options); + + return { + update(opts: TimeSeriesChartOptions): void { + doPlot(opts); + }, + hoverTrace(traceName: string | null): void { + if (!chartDiv || !initialized) return; + plotReady.then(() => { + if (!chartDiv) return; + if (!traceName) { + // Restore all traces to normal appearance + const allIndices = Array.from({ length: totalTraceCount }, (_, i) => i); + if (allIndices.length > 0) { + try { + Plotly.restyle(chartDiv, { opacity: 1.0, 'line.width': 1.5 }, allIndices); + } catch { /* ok */ } + } + return; + } + const curveNumber = traceNames.indexOf(traceName); + if (curveNumber < 0) return; + try { + // Dim all traces + const allIndices = Array.from({ length: totalTraceCount }, (_, i) => i); + if (allIndices.length > 0) { + Plotly.restyle(chartDiv, { opacity: 0.2, 'line.width': 1.5 }, allIndices); + } + // Emphasize the hovered trace + Plotly.restyle(chartDiv, { opacity: 1.0, 'line.width': 3 }, [curveNumber]); + } catch { /* ok */ } + }).catch(err => { + console.warn('Chart operation failed:', err); + }); + }, + destroy(): void { + if (chartDiv && initialized) { + try { Plotly.purge(chartDiv); } catch { /* ok */ } + } + chartDiv = null; + initialized = false; + traceNames = []; + totalTraceCount = 0; + hasScatterTrace = false; + savedYAxis = null; + getRawValues = undefined; + traceColorMap = new Map(); + }, + }; +} diff --git a/lnt/server/ui/v5/frontend/src/events.ts b/lnt/server/ui/v5/frontend/src/events.ts new file mode 100644 index 000000000..ea3d913e2 --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/events.ts @@ -0,0 +1,21 @@ +// Custom DOM event names used for inter-module communication. +export const CHART_ZOOM = 'chart-zoom' as const; +export const CHART_HOVER = 'chart-hover' as const; +export const TABLE_HOVER = 'table-hover' as const; +export const TEST_FILTER_CHANGE = 'test-filter-change' as const; +export const SETTINGS_CHANGE = 'settings-change' as const; +export const GRAPH_TABLE_HOVER = 'graph-table-hover' as const; +export const GRAPH_CHART_HOVER = 'graph-chart-hover' as const; + +/** Type-safe wrapper for addEventListener with CustomEvent detail. + * Returns a cleanup function to remove the listener. */ +export function onCustomEvent<T>( + name: string, + handler: (detail: T) => void, +): () => void { + const listener = ((e: CustomEvent<T>) => { + handler(e.detail); + }) as EventListener; + document.addEventListener(name, listener); + return () => document.removeEventListener(name, listener); +} diff --git a/lnt/server/ui/v5/frontend/src/main.ts b/lnt/server/ui/v5/frontend/src/main.ts new file mode 100644 index 000000000..2257ab953 --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/main.ts @@ -0,0 +1,75 @@ +// main.ts — SPA entry point for the v5 UI. + +import { setApiBase } from './api'; +import { addRoute, initRouter } from './router'; +import { renderNav, updateActiveNavLink } from './components/nav'; +import { el } from './utils'; +import './style.css'; + +// Page modules +import { dashboardPage } from './pages/dashboard'; +import { machineListPage } from './pages/machine-list'; +import { machineDetailPage } from './pages/machine-detail'; +import { runDetailPage } from './pages/run-detail'; +import { orderDetailPage } from './pages/order-detail'; +import { graphPage } from './pages/graph'; +import { comparePage } from './pages/compare'; +import { regressionListPage } from './pages/regression-list'; +import { regressionDetailPage } from './pages/regression-detail'; +import { fieldChangeTriagePage } from './pages/field-change-triage'; +import { adminPage } from './pages/admin'; + +declare const lnt_url_base: string; + +function init(): void { + const root = document.getElementById('v5-app'); + if (!root) return; + + const testsuite = root.getAttribute('data-testsuite') || ''; + const testsuites: string[] = JSON.parse( + root.getAttribute('data-testsuites') || '[]' + ); + const v4Url = root.getAttribute('data-v4-url') || '#'; + + // Set API base from global set in layout.html + const urlBase = typeof lnt_url_base !== 'undefined' ? lnt_url_base : ''; + setApiBase(urlBase); + + // Render nav bar (persistent across route changes) + const nav = renderNav({ testsuite, testsuites, v4Url, urlBase }); + root.append(nav); + + // Page content container + const pageContainer = el('div', { id: 'v5-page' }); + root.append(pageContainer); + + if (testsuite) { + // Normal testsuite context — register all routes + addRoute('/', dashboardPage); + addRoute('/machines', machineListPage); + addRoute('/machines/:name', machineDetailPage); + addRoute('/runs/:uuid', runDetailPage); + addRoute('/orders/:value', orderDetailPage); + addRoute('/graph', graphPage); + addRoute('/compare', comparePage); + addRoute('/regressions', regressionListPage); + addRoute('/regressions/:uuid', regressionDetailPage); + addRoute('/field-changes', fieldChangeTriagePage); + + const basePath = `${urlBase}/v5/${encodeURIComponent(testsuite)}`; + initRouter(pageContainer, basePath, updateActiveNavLink); + } else { + // No testsuite — admin-only context (served at /v5/admin) + addRoute('/admin', adminPage); + + const basePath = `${urlBase}/v5`; + initRouter(pageContainer, basePath, updateActiveNavLink); + } +} + +// Start +if (document.readyState === 'loading') { + document.addEventListener('DOMContentLoaded', init); +} else { + init(); +} diff --git a/lnt/server/ui/v5/frontend/src/pages/admin.ts b/lnt/server/ui/v5/frontend/src/pages/admin.ts new file mode 100644 index 000000000..1b7dee8a1 --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/pages/admin.ts @@ -0,0 +1,536 @@ +// pages/admin.ts — Admin page with API Keys and Test Suites tabs. +// Not test-suite specific — served at /v5/admin. + +import type { PageModule, RouteParams } from '../router'; +import type { APIKeyItem, TestSuiteInfo } from '../types'; +import { getApiKeys, createApiKey, revokeApiKey, getTestSuiteInfo, createTestSuite, deleteTestSuite, authErrorMessage } from '../api'; +import { removeSuiteFromNav, addSuiteToNav } from '../components/nav'; +import { el, formatTime } from '../utils'; + +let controller: AbortController | null = null; + +export const adminPage: PageModule = { + mount(container: HTMLElement, params: RouteParams): void { + if (controller) controller.abort(); + controller = new AbortController(); + const { signal } = controller; + + // Get available test suites from the HTML data attribute + const root = document.getElementById('v5-app'); + const testsuites: string[] = root + ? JSON.parse(root.getAttribute('data-testsuites') || '[]') + : []; + + container.append(el('h2', { class: 'page-header' }, 'Admin')); + + // Tab bar + const tabBar = el('div', { class: 'admin-tabs' }); + const keysTab = el('button', { class: 'admin-tab admin-tab-active' }, 'API Keys'); + const schemasTab = el('button', { class: 'admin-tab' }, 'Test Suites'); + const createSuiteTab = el('button', { class: 'admin-tab' }, 'Create Suite'); + tabBar.append(keysTab, schemasTab, createSuiteTab); + container.append(tabBar); + + const tabContent = el('div', { class: 'admin-tab-content' }); + container.append(tabContent); + + const allTabs = [keysTab, schemasTab, createSuiteTab]; + function activateTab(active: HTMLElement): void { + for (const t of allTabs) t.classList.remove('admin-tab-active'); + active.classList.add('admin-tab-active'); + } + + keysTab.addEventListener('click', () => { + activateTab(keysTab); + renderApiKeysTab(tabContent, signal); + }); + + schemasTab.addEventListener('click', () => { + activateTab(schemasTab); + renderSchemasTab(tabContent, testsuites, signal); + }); + + createSuiteTab.addEventListener('click', () => { + activateTab(createSuiteTab); + renderCreateSuiteTab(tabContent, testsuites, signal, () => { + // On create success: switch to Test Suites tab to see the new suite + activateTab(schemasTab); + renderSchemasTab(tabContent, testsuites, signal); + }); + }); + + // Default to API Keys tab + renderApiKeysTab(tabContent, signal); + }, + + unmount(): void { + if (controller) { controller.abort(); controller = null; } + }, +}; + +// --------------------------------------------------------------------------- +// API Keys Tab +// --------------------------------------------------------------------------- + +function renderApiKeysTab(container: HTMLElement, signal: AbortSignal): void { + container.replaceChildren( + el('span', { class: 'progress-label' }, 'Loading API keys...'), + ); + + getApiKeys(signal) + .then(keys => { + container.replaceChildren(); + renderCreateForm(container); + renderKeysTable(container, keys); + }) + .catch(err => { + container.replaceChildren( + el('p', { class: 'error-banner' }, authErrorMessage(err)), + ); + }); +} + +function renderCreateForm(container: HTMLElement): void { + const form = el('div', { class: 'admin-create-form' }); + + const nameInput = el('input', { + type: 'text', + class: 'admin-input', + placeholder: 'Key name...', + }) as HTMLInputElement; + + const scopeSelect = el('select', { class: 'admin-select' }) as HTMLSelectElement; + for (const scope of ['read', 'submit', 'triage', 'manage', 'admin']) { + scopeSelect.append(el('option', { value: scope }, scope)); + } + + const createBtn = el('button', { class: 'admin-btn' }, 'Create Key'); + const feedback = el('div', {}); + + createBtn.addEventListener('click', () => { + const name = nameInput.value.trim(); + if (!name) { + feedback.replaceChildren( + el('p', { class: 'error-banner' }, 'Key name is required.'), + ); + return; + } + + createBtn.setAttribute('disabled', ''); + feedback.replaceChildren( + el('span', { class: 'progress-label' }, 'Creating...'), + ); + + createApiKey(name, scopeSelect.value) + .then(result => { + nameInput.value = ''; + const copyBtn = el('button', { class: 'admin-copy-btn', title: 'Copy to clipboard' }, '\u{1F4CB}'); + copyBtn.addEventListener('click', () => { + navigator.clipboard.writeText(result.key).then(() => { + copyBtn.textContent = '\u2713'; + setTimeout(() => { copyBtn.textContent = '\u{1F4CB}'; }, 1500); + }); + }); + const tokenBox = el('div', { class: 'admin-raw-token' }, + el('span', {}, result.key), + copyBtn, + ); + feedback.replaceChildren( + el('div', { class: 'admin-key-created' }, + el('p', {}, 'Key created. Copy the token now — it will not be shown again:'), + tokenBox, + ), + ); + createBtn.removeAttribute('disabled'); + // Refresh the keys table + const tableContainer = container.querySelector('.admin-keys-table-container'); + if (tableContainer) { + getApiKeys().then(keys => { + renderKeysTable(container, keys); + }).catch(() => { /* keep existing table */ }); + } + }) + .catch(err => { + createBtn.removeAttribute('disabled'); + feedback.replaceChildren( + el('p', { class: 'error-banner' }, authErrorMessage(err)), + ); + }); + }); + + form.append( + el('label', {}, 'Create API Key'), + el('div', { class: 'admin-form-row' }, nameInput, scopeSelect, createBtn), + feedback, + ); + container.append(form); +} + +function renderKeysTable(container: HTMLElement, keys: APIKeyItem[]): void { + // Remove existing table if present + const existing = container.querySelector('.admin-keys-table-container'); + if (existing) existing.remove(); + + const wrapper = el('div', { class: 'admin-keys-table-container' }); + + if (keys.length === 0) { + wrapper.append(el('p', {}, 'No API keys found.')); + container.append(wrapper); + return; + } + + const table = el('table', { class: 'comparison-table' }) as HTMLTableElement; + const thead = el('thead'); + const headerRow = el('tr'); + for (const label of ['Prefix', 'Name', 'Scope', 'Created', 'Last Used', 'Active', '']) { + headerRow.append(el('th', {}, label)); + } + thead.append(headerRow); + table.append(thead); + + const tbody = el('tbody'); + for (const key of keys) { + const tr = el('tr'); + tr.append( + el('td', {}, key.prefix), + el('td', {}, key.name), + el('td', {}, key.scope), + el('td', {}, formatTime(key.created_at)), + el('td', {}, formatTime(key.last_used_at)), + el('td', {}, key.is_active ? 'Yes' : 'No'), + ); + + const actionTd = el('td', {}); + if (key.is_active) { + const revokeBtn = el('button', { class: 'admin-btn admin-btn-danger' }, 'Revoke'); + revokeBtn.addEventListener('click', () => { + revokeBtn.setAttribute('disabled', ''); + revokeBtn.textContent = 'Revoking...'; + revokeApiKey(key.prefix) + .then(() => { + // Refresh + getApiKeys().then(updated => { + renderKeysTable(container, updated); + }).catch(() => { + revokeBtn.removeAttribute('disabled'); + revokeBtn.textContent = 'Revoke'; + }); + }) + .catch(err => { + revokeBtn.removeAttribute('disabled'); + revokeBtn.textContent = 'Revoke'; + // Show error inline in the row + actionTd.append(el('span', { class: 'error-banner', style: 'display:inline; margin-left:4px; font-size:12px' }, authErrorMessage(err))); + }); + }); + actionTd.append(revokeBtn); + } + tr.append(actionTd); + tbody.append(tr); + } + table.append(tbody); + + wrapper.append(table); + container.append(wrapper); +} + +// --------------------------------------------------------------------------- +// Schemas (Test Suites) Tab +// --------------------------------------------------------------------------- + +function renderSchemasTab(container: HTMLElement, _testsuites: string[], signal: AbortSignal): void { + container.replaceChildren(); + + // Always read the current suites from the DOM attribute (single source of truth). + // The _testsuites parameter is kept for API compatibility but not used. + const root = document.getElementById('v5-app'); + let suites: string[] = root + ? JSON.parse(root.getAttribute('data-testsuites') || '[]') + : [..._testsuites]; + + // --- Suite selector + viewer --- + const selectorRow = el('div', { class: 'admin-form-row', style: 'margin-bottom: 12px' }); + selectorRow.append(el('label', {}, 'Test Suite: ')); + const suiteSelect = el('select', { class: 'admin-select' }) as HTMLSelectElement; + selectorRow.append(suiteSelect); + container.append(selectorRow); + + const schemaContent = el('div', {}); + container.append(schemaContent); + + function populateSelect(selectName?: string): void { + suiteSelect.replaceChildren(); + if (suites.length === 0) { + suiteSelect.append(el('option', { value: '' }, '(no test suites)')); + schemaContent.replaceChildren(el('p', {}, 'No test suites available.')); + return; + } + for (const name of suites) { + suiteSelect.append(el('option', { value: name }, name)); + } + if (selectName && suites.includes(selectName)) { + suiteSelect.value = selectName; + } + loadSchema(); + } + + function loadSchema(): void { + const ts = suiteSelect.value; + if (!ts) return; + schemaContent.replaceChildren( + el('span', { class: 'progress-label' }, 'Loading schema...'), + ); + getTestSuiteInfo(ts, signal) + .then(info => { + schemaContent.replaceChildren(); + renderSchemaContent(schemaContent, info); + renderDeleteSuite(schemaContent, ts, () => reloadSuites()); + }) + .catch(err => { + schemaContent.replaceChildren( + el('p', { class: 'error-banner' }, `Failed to load schema: ${err}`), + ); + }); + } + + function reloadSuites(selectName?: string): void { + // Re-read from the HTML attribute which is kept in sync on create/delete. + const root = document.getElementById('v5-app'); + if (root) { + suites = JSON.parse(root.getAttribute('data-testsuites') || '[]'); + } + populateSelect(selectName); + } + + suiteSelect.addEventListener('change', loadSchema); + populateSelect(); +} + +function renderCreateSuiteTab( + container: HTMLElement, + _suites: string[], + signal: AbortSignal, + onCreated: () => void, +): void { + container.replaceChildren(); + + const section = el('div', { class: 'admin-create-form' }); + section.append(el('label', {}, 'Create Test Suite')); + + const nameInput = el('input', { + type: 'text', + class: 'admin-input', + placeholder: 'Suite name (e.g., my_suite)...', + }) as HTMLInputElement; + + const jsonArea = el('textarea', { + class: 'admin-textarea', + placeholder: '{\n "format_version": "2",\n "name": "my_suite",\n "metrics": [\n {"name": "exec_time", "type": "Real", "bigger_is_better": false}\n ],\n "run_fields": [\n {"name": "revision", "order": true}\n ],\n "machine_fields": [\n {"name": "hostname"}\n ]\n}', + }) as HTMLTextAreaElement; + jsonArea.rows = 10; + + const createBtn = el('button', { class: 'admin-btn' }, 'Create'); + const feedback = el('div', {}); + + createBtn.addEventListener('click', () => { + const name = nameInput.value.trim(); + if (!name) { + feedback.replaceChildren(el('p', { class: 'error-banner' }, 'Suite name is required.')); + return; + } + + let payload: Record<string, unknown>; + try { + payload = JSON.parse(jsonArea.value); + } catch { + feedback.replaceChildren(el('p', { class: 'error-banner' }, 'Invalid JSON.')); + return; + } + + // Ensure name in payload matches the name input + payload['name'] = name; + if (!payload['format_version']) payload['format_version'] = '2'; + + createBtn.setAttribute('disabled', ''); + feedback.replaceChildren(el('span', { class: 'progress-label' }, 'Creating...')); + + createTestSuite(payload, signal) + .then(() => { + createBtn.removeAttribute('disabled'); + nameInput.value = ''; + jsonArea.value = ''; + feedback.replaceChildren( + el('p', { class: 'admin-key-created', style: 'padding: 8px' }, + `Test suite '${name}' created successfully.`), + ); + // Update the DOM attribute (source of truth) and nav bar so the new suite is selectable. + // Do NOT mutate the shared `suites` array — rebuild from the DOM attribute instead. + const root = document.getElementById('v5-app'); + if (root) { + const current: string[] = JSON.parse(root.getAttribute('data-testsuites') || '[]'); + const updated = [...current, name].sort(); + root.setAttribute('data-testsuites', JSON.stringify(updated)); + } + addSuiteToNav(name); + onCreated(); + }) + .catch(err => { + createBtn.removeAttribute('disabled'); + feedback.replaceChildren(el('p', { class: 'error-banner' }, authErrorMessage(err))); + }); + }); + + section.append( + el('div', { class: 'admin-form-row' }, nameInput), + jsonArea, + el('div', { class: 'admin-form-row', style: 'margin-top: 8px' }, createBtn), + feedback, + ); + container.append(section); +} + +function renderDeleteSuite( + container: HTMLElement, + suiteName: string, + onDeleted: () => void, +): void { + const section = el('div', { class: 'admin-delete-section' }); + + const deleteToggle = el('button', { class: 'admin-btn admin-btn-danger' }, 'Delete This Suite'); + section.append(deleteToggle); + + const confirmPanel = el('div', { class: 'admin-delete-confirm', style: 'display: none' }); + + confirmPanel.append(el('p', { class: 'admin-delete-warning' }, + `Deleting test suite '${suiteName}' will permanently destroy all machines, runs, ` + + 'orders, samples, regressions, and field changes associated with it. ' + + 'This cannot be undone.', + )); + + confirmPanel.append(el('p', {}, `Type "${suiteName}" to confirm:`)); + + const confirmInput = el('input', { + type: 'text', + class: 'admin-input', + placeholder: suiteName, + }) as HTMLInputElement; + + const confirmBtn = el('button', { + class: 'admin-btn admin-btn-danger', + disabled: '', + }, 'Delete permanently') as HTMLButtonElement; + + const feedback = el('div', {}); + + confirmInput.addEventListener('input', () => { + if (confirmInput.value === suiteName) { + confirmBtn.removeAttribute('disabled'); + } else { + confirmBtn.setAttribute('disabled', ''); + } + }); + + confirmBtn.addEventListener('click', () => { + confirmBtn.setAttribute('disabled', ''); + confirmBtn.textContent = 'Deleting...'; + feedback.replaceChildren(); + + deleteTestSuite(suiteName) + .then(() => { + section.replaceChildren( + el('p', { class: 'admin-key-created', style: 'padding: 8px' }, + `Test suite '${suiteName}' deleted.`), + ); + // Remove from the suites list tracked by the parent + const root = document.getElementById('v5-app'); + if (root) { + const current: string[] = JSON.parse(root.getAttribute('data-testsuites') || '[]'); + const updated = current.filter(s => s !== suiteName); + root.setAttribute('data-testsuites', JSON.stringify(updated)); + } + removeSuiteFromNav(suiteName); + onDeleted(); + }) + .catch(err => { + confirmBtn.removeAttribute('disabled'); + confirmBtn.textContent = 'Delete permanently'; + feedback.replaceChildren(el('p', { class: 'error-banner' }, authErrorMessage(err))); + }); + }); + + confirmPanel.append( + el('div', { class: 'admin-form-row' }, confirmInput, confirmBtn), + feedback, + ); + section.append(confirmPanel); + + deleteToggle.addEventListener('click', () => { + const visible = confirmPanel.style.display !== 'none'; + confirmPanel.style.display = visible ? 'none' : 'block'; + deleteToggle.textContent = visible ? 'Delete This Suite' : 'Cancel'; + deleteToggle.classList.toggle('admin-btn-danger', visible); + if (visible) { + confirmInput.value = ''; + confirmBtn.setAttribute('disabled', ''); + } + }); + + container.append(section); +} + +function renderSchemaContent(container: HTMLElement, info: TestSuiteInfo): void { + + // Metrics table + if (info.schema.metrics.length > 0) { + container.append(el('h4', {}, 'Metrics')); + const table = el('table', { class: 'comparison-table' }) as HTMLTableElement; + const thead = el('thead'); + const headerRow = el('tr'); + for (const label of ['Name', 'Type', 'Display Name', 'Unit', 'Bigger is Better']) { + headerRow.append(el('th', {}, label)); + } + thead.append(headerRow); + table.append(thead); + + const tbody = el('tbody'); + for (const f of info.schema.metrics) { + const tr = el('tr'); + tr.append( + el('td', {}, f.name), + el('td', {}, f.type), + el('td', {}, f.display_name || '\u2014'), + el('td', {}, f.unit ? `${f.unit} (${f.unit_abbrev || ''})` : '\u2014'), + el('td', {}, f.bigger_is_better === null ? '\u2014' : f.bigger_is_better ? 'Yes' : 'No'), + ); + tbody.append(tr); + } + table.append(tbody); + container.append(table); + } + + // Other schema sections + for (const [label, fields] of [ + ['Order Fields', info.schema.order_fields], + ['Machine Fields', info.schema.machine_fields], + ['Run Fields', info.schema.run_fields], + ] as const) { + if (fields && fields.length > 0) { + container.append(el('h4', {}, label)); + const table = el('table', { class: 'comparison-table' }) as HTMLTableElement; + const thead = el('thead'); + const hr = el('tr'); + hr.append(el('th', {}, 'Name'), el('th', {}, 'Type')); + thead.append(hr); + table.append(thead); + + const tbody = el('tbody'); + for (const f of fields) { + const tr = el('tr'); + tr.append(el('td', {}, f.name), el('td', {}, f.type)); + tbody.append(tr); + } + table.append(tbody); + container.append(table); + } + } +} diff --git a/lnt/server/ui/v5/frontend/src/pages/compare.ts b/lnt/server/ui/v5/frontend/src/pages/compare.ts new file mode 100644 index 000000000..f3d08eed4 --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/pages/compare.ts @@ -0,0 +1,289 @@ +// pages/compare.ts — Compare page module for the SPA. +// +// Absorbs the existing comparison code (comparison.ts, selection.ts, table.ts, +// chart.ts) into the SPA as a page module. The mount() function replaces what +// the old standalone main.ts init() did. +// +// Per-run sample caching: fetched samples are cached by run UUID. Changing the +// metric, aggregation, or noise re-aggregates from cache without API calls. +// Only new run UUIDs (from order/machine changes) trigger fetches. + +import type { PageModule, RouteParams } from '../router'; +import type { FieldInfo, ComparisonRow, SampleInfo } from '../types'; +import { getFields, getOrders, getSamples } from '../api'; +import { + CHART_ZOOM, CHART_HOVER, TABLE_HOVER, + TEST_FILTER_CHANGE, SETTINGS_CHANGE, + onCustomEvent, +} from '../events'; +import { getState, applyUrlState } from '../state'; +import { + setCachedData, renderSelectionPanel, +} from '../selection'; +import { + aggregateSamplesWithinRun, aggregateAcrossRuns, computeComparison, +} from '../comparison'; +import { renderTable, filterToTests, highlightRow, resetTable } from '../table'; +import { renderChart, highlightPoint, destroyChart } from '../chart'; +import { el } from '../utils'; + +/** Cleanup functions for document-level event listeners. */ +let eventCleanups: Array<() => void> = []; +/** AbortController for in-flight sample fetches. */ +let fetchController: AbortController | null = null; +/** Per-run sample cache: run UUID → samples. */ +let sampleCache = new Map<string, SampleInfo[]>(); +/** Tests manually hidden by the user (click toggle) or by hideNoise. */ +let manuallyHidden = new Set<string>(); + +export const comparePage: PageModule = { + mount(container: HTMLElement, params: RouteParams): void { + const ts = params.testsuite; + + // Restore state from URL query params + applyUrlState(window.location.search); + + const header = el('h2', { class: 'page-header' }, 'Compare'); + container.append(header); + container.append(el('p', { class: 'progress-label' }, 'Loading fields and orders...')); + + // Containers + const selectionContainer = el('div', {}); + const progressContainer = el('div', {}); + const errorContainer = el('div', {}); + const chartContainer = el('div', { class: 'chart-container' }, + el('p', { class: 'no-chart-data' }, 'No data to chart.'), + ); + const tableContainer = el('div', { class: 'table-container' }); + + let lastRows: ComparisonRow[] = []; + let lastFields: FieldInfo[] = []; + + // ----- Compute effective hidden set and render ----- + + /** A test is hidden if it's manually hidden OR (noise + hideNoise checked). */ + function computeEffectiveHidden(): Set<string> { + const state = getState(); + const effective = new Set(manuallyHidden); + if (state.hideNoise) { + for (const r of lastRows) { + if (r.status === 'noise') effective.add(r.test); + } + } + return effective; + } + + function renderTableAndChart(): void { + const effectiveHidden = computeEffectiveHidden(); + const visibleRows = lastRows.filter(r => !effectiveHidden.has(r.test)); + renderTable(tableContainer, lastRows, { + hiddenTests: effectiveHidden, + onToggle: (test) => { + if (manuallyHidden.has(test)) { + manuallyHidden.delete(test); + } else { + manuallyHidden.add(test); + } + renderTableAndChart(); + }, + onIsolate: (test) => { + const effectiveNow = computeEffectiveHidden(); + const state = getState(); + const lf = state.testFilter ? state.testFilter.toLowerCase() : ''; + const visibleTests = lastRows + .filter(r => r.sidePresent === 'both' && !effectiveNow.has(r.test) + && (!lf || r.test.toLowerCase().includes(lf))) + .map(r => r.test); + + if (visibleTests.length === 1 && visibleTests[0] === test) { + // Already isolated — restore all + manuallyHidden = new Set(); + } else { + // Hide all visible except the target + manuallyHidden = new Set( + lastRows + .filter(r => r.sidePresent === 'both' && r.test !== test + && (!lf || r.test.toLowerCase().includes(lf))) + .map(r => r.test), + ); + } + renderTableAndChart(); + }, + }); + renderChart(chartContainer, visibleRows, true); + } + + // ----- Recompute from cache (no API calls) ----- + + function recomputeFromCache(): void { + const state = getState(); + if (!state.metric) return; + + const metricField = lastFields.find(f => f.name === state.metric); + const biggerIsBetter = metricField?.bigger_is_better ?? false; + + // Aggregate from cached samples + const perRunA = state.sideA.runs + .map(uuid => sampleCache.get(uuid)) + .filter((s): s is SampleInfo[] => s !== undefined) + .map(s => aggregateSamplesWithinRun(s, state.metric, state.sampleAgg)); + + const perRunB = state.sideB.runs + .map(uuid => sampleCache.get(uuid)) + .filter((s): s is SampleInfo[] => s !== undefined) + .map(s => aggregateSamplesWithinRun(s, state.metric, state.sampleAgg)); + + const mapA = aggregateAcrossRuns(perRunA, state.sideA.runAgg); + const mapB = aggregateAcrossRuns(perRunB, state.sideB.runAgg); + + const rows = computeComparison(mapA, mapB, biggerIsBetter, state.noise); + lastRows = rows; + + renderTableAndChart(); + } + + // ----- Compare callback ----- + + function doCompare(): void { + const state = getState(); + if (state.sideA.runs.length === 0 || state.sideB.runs.length === 0 || !state.metric) { + return; + } + + errorContainer.replaceChildren(); + + // Check which runs need fetching + const allRunUuids = [...state.sideA.runs, ...state.sideB.runs]; + const uncached = allRunUuids.filter(uuid => !sampleCache.has(uuid)); + + if (uncached.length === 0) { + // All data cached — recompute immediately without any API calls + recomputeFromCache(); + return; + } + + // New runs to fetch — order or machine changed. Evict stale cache + // entries (old run UUIDs that are no longer selected). This is NOT + // done on toggle (all cached → early return above), so unchecking + // a run preserves its cached data for re-checking. + const inUse = new Set(allRunUuids); + for (const uuid of sampleCache.keys()) { + if (!inUse.has(uuid)) sampleCache.delete(uuid); + } + + // Abort any previous fetch + if (fetchController) fetchController.abort(); + fetchController = new AbortController(); + const { signal } = fetchController; + + // Track per-run cumulative counts for accurate total across parallel fetches + const perRunLoaded = new Map<string, number>(); + progressContainer.replaceChildren( + el('span', { class: 'progress-label' }, 'Loading samples...'), + ); + + function updateSampleProgress(uuid: string, loaded: number): void { + perRunLoaded.set(uuid, loaded); + let total = 0; + for (const n of perRunLoaded.values()) total += n; + progressContainer.replaceChildren( + el('span', { class: 'progress-label' }, `Loading ${total} samples...`), + ); + } + + // Fetch only uncached runs + const fetchPromises = uncached.map(uuid => + getSamples(ts, uuid, signal, (loaded) => updateSampleProgress(uuid, loaded)).then(samples => { + sampleCache.set(uuid, samples); + }), + ); + + Promise.all(fetchPromises) + .then(() => { + progressContainer.replaceChildren(); + recomputeFromCache(); + }) + .catch((err: unknown) => { + progressContainer.replaceChildren(); + if (err instanceof DOMException && err.name === 'AbortError') return; + errorContainer.replaceChildren( + el('p', { class: 'error-banner' }, `Comparison failed: ${err}`), + ); + }); + } + + // ----- Fetch initial data ----- + + Promise.all([getFields(ts), getOrders(ts)]) + .then(([fields, orders]) => { + lastFields = fields; + container.replaceChildren(header); + + // Wire up selection panel with compare callback + setCachedData(orders, fields, ts, doCompare); + + container.append(selectionContainer); + renderSelectionPanel(selectionContainer); + + container.append(progressContainer, errorContainer, chartContainer, tableContainer); + + // Wire event listeners (all return cleanup functions) + eventCleanups.push( + onCustomEvent<Set<string> | null>(CHART_ZOOM, (tests) => { + filterToTests(tests); + }), + onCustomEvent<string | null>(CHART_HOVER, (testName) => { + highlightRow(testName); + }), + onCustomEvent<string | null>(TABLE_HOVER, (testName) => { + highlightPoint(testName); + }), + onCustomEvent(SETTINGS_CHANGE, () => { + // Noise % or hideNoise changed. Recompute from cache so status + // classifications update with the new threshold. hideNoise is + // applied as a separate filter in computeEffectiveHidden(). + const state = getState(); + if (state.sideA.runs.length > 0 && state.sideB.runs.length > 0 && state.metric) { + recomputeFromCache(); + } else if (lastRows.length > 0) { + renderTableAndChart(); + } + }), + onCustomEvent(TEST_FILTER_CHANGE, () => { + if (lastRows.length > 0) { + renderTableAndChart(); + } + }), + ); + + // Auto-compare is handled by tryAutoCompare() in selection.ts, + // triggered when runs finish loading and state is valid. + }) + .catch((err: unknown) => { + container.replaceChildren( + header, + el('p', { class: 'error-banner' }, `Failed to load data: ${err}`), + ); + }); + }, + + unmount(): void { + // Remove document-level event listeners + for (const cleanup of eventCleanups) cleanup(); + eventCleanups = []; + + // Abort in-flight sample fetches + if (fetchController) { + fetchController.abort(); + fetchController = null; + } + + // Clear state + sampleCache.clear(); + manuallyHidden = new Set(); + + // Clean up modules with mutable state + destroyChart(); + resetTable(); + }, +}; diff --git a/lnt/server/ui/v5/frontend/src/pages/dashboard.ts b/lnt/server/ui/v5/frontend/src/pages/dashboard.ts new file mode 100644 index 000000000..14bd8fb87 --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/pages/dashboard.ts @@ -0,0 +1,114 @@ +// pages/dashboard.ts — Dashboard landing page. + +import type { PageModule, RouteParams } from '../router'; +import type { OrderDetail } from '../types'; +import { getRecentRuns, getOrder } from '../api'; +import { el, spaLink, formatTime, truncate, primaryOrderValue } from '../utils'; +import { renderDataTable } from '../components/data-table'; + +let controller: AbortController | null = null; + +export const dashboardPage: PageModule = { + mount(container: HTMLElement, params: RouteParams): void { + if (controller) controller.abort(); + controller = new AbortController(); + + const ts = params.testsuite; + container.append(el('h2', { class: 'page-header' }, 'Dashboard')); + + const recentSection = el('div', { class: 'dashboard-section' }); + container.append(recentSection); + + loadRecentOrders(ts, recentSection, controller.signal); + }, + + unmount(): void { + if (controller) { controller.abort(); controller = null; } + }, +}; + +interface OrderRow { + orderValue: string; + tag: string | null; + latestRun: string; + latestRunUuid: string; +} + +async function loadRecentOrders(ts: string, section: HTMLElement, signal: AbortSignal): Promise<void> { + section.append(el('h3', {}, 'Recent Orders')); + const loading = el('p', { class: 'progress-label' }, 'Loading recent runs...'); + section.append(loading); + + try { + const result = await getRecentRuns(ts, { limit: 50, sort: '-start_time' }, signal); + + // Group by primary order field value, tracking the latest run + const orderMap = new Map<string, { latestRun: string; latestRunUuid: string }>(); + for (const run of result.items) { + const ov = primaryOrderValue(run.order); + if (!ov) continue; + let entry = orderMap.get(ov); + if (!entry) { + entry = { latestRun: run.start_time || '', latestRunUuid: run.uuid }; + orderMap.set(ov, entry); + } + if (run.start_time && run.start_time > entry.latestRun) { + entry.latestRun = run.start_time; + entry.latestRunUuid = run.uuid; + } + } + + // Batch-fetch order details to get tags (batches of 5 to avoid overwhelming connections) + const orderValues = [...orderMap.keys()]; + const tagMap = new Map<string, string | null>(); + const batchSize = 5; + for (let i = 0; i < orderValues.length; i += batchSize) { + const batch = orderValues.slice(i, i + batchSize); + await Promise.all(batch.map(async (v) => { + try { + const detail: OrderDetail = await getOrder(ts, v, signal); + tagMap.set(v, detail.tag); + } catch { + tagMap.set(v, null); + } + })); + } + + const rows: OrderRow[] = orderValues.map(v => { + const entry = orderMap.get(v)!; + return { + orderValue: v, + tag: tagMap.get(v) || null, + latestRun: entry.latestRun, + latestRunUuid: entry.latestRunUuid, + }; + }); + + loading.remove(); + + if (rows.length === 0) { + section.append(el('p', { class: 'no-results' }, 'No recent runs found.')); + return; + } + + renderDataTable(section, { + columns: [ + { key: 'orderValue', label: 'Order', + render: (r) => { + const label = truncate(r.orderValue, 12) + (r.tag ? ` (${r.tag})` : ''); + return spaLink(label, `/orders/${encodeURIComponent(r.orderValue)}`); + } }, + { key: 'latestRun', label: 'Latest Run', + render: (r) => spaLink( + formatTime(r.latestRun, ''), + `/runs/${encodeURIComponent(r.latestRunUuid)}`, + ) }, + ], + rows, + emptyMessage: 'No recent orders.', + }); + } catch (e: unknown) { + loading.remove(); + section.append(el('p', { class: 'error-banner' }, `Failed to load recent orders: ${e}`)); + } +} diff --git a/lnt/server/ui/v5/frontend/src/pages/field-change-triage.ts b/lnt/server/ui/v5/frontend/src/pages/field-change-triage.ts new file mode 100644 index 000000000..f463f4a26 --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/pages/field-change-triage.ts @@ -0,0 +1,13 @@ +import type { PageModule, RouteParams } from '../router'; +import { el } from '../utils'; + +export const fieldChangeTriagePage: PageModule = { + mount(container: HTMLElement, _params: RouteParams): void { + container.append( + el('div', { class: 'page-placeholder' }, + el('h2', {}, 'Field Change Triage'), + el('p', {}, 'Not implemented yet.'), + ) + ); + }, +}; diff --git a/lnt/server/ui/v5/frontend/src/pages/graph.ts b/lnt/server/ui/v5/frontend/src/pages/graph.ts new file mode 100644 index 000000000..2c2c22e45 --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/pages/graph.ts @@ -0,0 +1,1019 @@ +// pages/graph.ts — Time-series graph page with lazy loading and client-side caching. + +import type { PageModule, RouteParams } from '../router'; +import type { AggFn, QueryDataPoint } from '../types'; +import { getFields, getOrders, fetchOneCursorPage, apiUrl, queryDataPoints } from '../api'; +import type { MachineRunInfo, OrderSummary } from '../types'; +import { el, debounce, getAggFn, primaryOrderValue, TRACE_SEP } from '../utils'; +import { navigate } from '../router'; +import { onCustomEvent, GRAPH_TABLE_HOVER, GRAPH_CHART_HOVER } from '../events'; +import { renderMachineCombobox } from '../components/machine-combobox'; +import { renderMetricSelector, filterMetricFields } from '../components/metric-selector'; +import { renderOrderSearch, type OrderSuggestion } from '../components/order-search'; +import { + type TimeSeriesTrace, type PinnedOrder, type ChartHandle, + createTimeSeriesChart, +} from '../components/time-series-chart'; +import { createLegendTable, type LegendEntry, type LegendTableHandle } from '../components/legend-table'; + +const DEFAULT_CAP = 20; +const PAGE_LIMIT = '10000'; +const CHART_BATCH_SIZE = 10; +const PIN_COLORS = ['#e377c2', '#ff7f0e', '#9467bd', '#8c564b', '#17becf']; +const PLOTLY_COLORS = [ + '#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd', + '#8c564b', '#e377c2', '#7f7f7f', '#bcbd22', '#17becf', +]; +const MACHINE_SYMBOLS = [ + 'circle', 'triangle-up', 'square', 'diamond', 'x', + 'cross', 'star', 'pentagon', 'hexagon', 'hexagram', +]; +/** Unicode characters matching MACHINE_SYMBOLS for display in chips and legend. */ +const SYMBOL_CHARS = ['●', '▲', '■', '◆', '✕', '+', '★', '⬠', '⬡', '✡']; + +// --------------------------------------------------------------------------- +// Cache — keyed by 'machine::metric' +// --------------------------------------------------------------------------- + +interface MetricCache { + points: QueryDataPoint[]; + nextCursor: string | null; + loading: boolean; + hasInitialData: boolean; + complete: boolean; +} + +let cache = new Map<string, MetricCache>(); +/** Per-machine scaffolds (order values). */ +let machineScaffolds = new Map<string, string[]>(); +let metricAborts = new Map<string, AbortController>(); +/** AbortController for in-flight scaffold fetches; aborted on unmount. */ +let scaffoldAbort: AbortController | null = null; +/** Cached suggestions for the pinned-order search (built from scaffold union + tags). */ +let cachedSuggestions: OrderSuggestion[] | null = null; +/** Cached orders fetched via getOrders — avoids re-fetching on every rebuildSuggestions call. */ +let cachedOrders: OrderSummary[] | null = null; + +function cacheKey(machine: string, metric: string): string { + return `${machine}::${metric}`; +} + +function abortForMachine(machine: string): void { + for (const [key, ctrl] of metricAborts) { + if (key.startsWith(machine + '::')) { + ctrl.abort(); + metricAborts.delete(key); + } + } +} + +function abortAllMetrics(): void { + for (const ctrl of metricAborts.values()) ctrl.abort(); + metricAborts.clear(); +} + +function getOrCreateCache(machine: string, metric: string): MetricCache { + const key = cacheKey(machine, metric); + let entry = cache.get(key); + if (!entry) { + entry = { points: [], nextCursor: null, loading: false, hasInitialData: false, complete: false }; + cache.set(key, entry); + } + return entry; +} + +// --------------------------------------------------------------------------- +// Module-scope UI state +// --------------------------------------------------------------------------- + +let machineComboCleanup: (() => void) | null = null; +let orderSearchCleanup: (() => void) | null = null; +let chartHandle: ChartHandle | null = null; +let legendHandle: LegendTableHandle | null = null; +let manuallyHidden = new Set<string>(); +let autoCapped = true; +/** Current visible trace names (updated on each render, used by legend callbacks). */ +let currentVisibleTraceNames: string[] = []; +/** The active trace name set from the last chart render, used to skip no-op chart updates. */ +let prevActiveTraceNames = new Set<string>(); +/** Pending requestAnimationFrame ID for deferred chart updates. */ +let pendingChartRAF: number | null = null; +/** Generation counter to cancel stale batched chart renders. */ +let chartRenderGen = 0; +let cleanupTableHover: (() => void) | null = null; +let cleanupChartHover: (() => void) | null = null; +/** List of selected machines (preserved across unmount/remount). */ +let machines: string[] = []; + +/** Check whether two sets contain the same elements. Exported for testing. */ +export function setsEqual(a: Set<string>, b: Set<string>): boolean { + if (a.size !== b.size) return false; + for (const item of a) { + if (!b.has(item)) return false; + } + return true; +} + +function assignColor(index: number): string { + return PLOTLY_COLORS[index % PLOTLY_COLORS.length]; +} + +function assignSymbol(machineIndex: number): string { + return MACHINE_SYMBOLS[machineIndex % MACHINE_SYMBOLS.length]; +} + +function assignSymbolChar(machineIndex: number): string { + return SYMBOL_CHARS[machineIndex % SYMBOL_CHARS.length]; +} + +// Re-export TRACE_SEP for test convenience +export { TRACE_SEP } from '../utils'; + +/** Build the trace name for a test×machine combination. */ +function traceName(testName: string, machine: string): string { + return `${testName}${TRACE_SEP}${machine}`; +} + +/** Extract the test name portion from a trace name (everything before the separator). */ +function testNameFromTrace(tn: string): string { + const idx = tn.lastIndexOf(TRACE_SEP); + return idx >= 0 ? tn.slice(0, idx) : tn; +} + +/** + * Compute the union of all machines' scaffolds, preserving order. + */ +function computeScaffoldUnion(): string[] | null { + if (machineScaffolds.size === 0) return null; + const seen = new Set<string>(); + const union: string[] = []; + for (const scaffold of machineScaffolds.values()) { + for (const ov of scaffold) { + if (!seen.has(ov)) { + seen.add(ov); + union.push(ov); + } + } + } + return union.length > 0 ? union : null; +} + +/** + * Determine which traces are active (plotted). + * The filter matches on the test name portion of the trace name only. + * Exported for testing. + */ +export function computeActiveTests( + allTraceNames: string[], + testFilter: string, + hidden: Set<string>, + capped: boolean, +): Set<string> { + // Apply text filter (matches on test name portion only) + let candidates: string[]; + if (testFilter) { + const lf = testFilter.toLowerCase(); + candidates = allTraceNames.filter(tn => { + const test = testNameFromTrace(tn); + return test.toLowerCase().includes(lf); + }); + } else { + candidates = allTraceNames; + } + + // 20-cap: only active when no filter and no manual toggles + if (capped && !testFilter && hidden.size === 0) { + return new Set(candidates.slice(0, DEFAULT_CAP)); + } + + // Remove manually hidden + return new Set(candidates.filter(n => !hidden.has(n))); +} + +export const graphPage: PageModule = { + mount(container: HTMLElement, params: RouteParams): void { + const ts = params.testsuite; + // Create a fresh abort controller for scaffold fetches this mount cycle. + scaffoldAbort = new AbortController(); + container.append(el('h2', { class: 'page-header' }, 'Graph')); + + // Parse URL state — URL is always the source of truth on mount. + const urlParams = new URLSearchParams(window.location.search); + machines = urlParams.getAll('machine').filter(Boolean); + let metric = urlParams.get('metric') || ''; + let testFilter = urlParams.get('test_filter') || ''; + let runAgg: AggFn = (urlParams.get('run_agg') as AggFn) || 'median'; + let sampleAgg: AggFn = (urlParams.get('sample_agg') as AggFn) || 'median'; + const pinValues = urlParams.getAll('pin'); + const pinnedOrders: Array<{ value: string; tag: string | null }> = pinValues.map(v => ({ value: v, tag: null })); + + // Progress + chart containers + const progressContainer = el('div', {}); + const warningContainer = el('div', {}); + const chartContainer = el('div', {}, + el('p', { class: 'no-chart-data' }, 'No data to plot.'), + ); + + // ----- Controls Panel ----- + const controlsPanel = el('div', { class: 'controls-panel' }); + container.append(controlsPanel); + + // ----- Controls Row 1: Metric, Test Filter, Aggregation ----- + const controlsRow = el('div', { class: 'graph-controls' }); + controlsPanel.append(controlsRow); + + // Metric selector (loaded async) + const metricGroup = el('div', {}); + const metricLoading = el('span', { class: 'progress-label' }, 'Loading metrics...'); + metricGroup.append(metricLoading); + controlsRow.append(metricGroup); + + getFields(ts).then(fields => { + metricLoading.remove(); + const initial = renderMetricSelector(metricGroup, filterMetricFields(fields), (m) => { + metric = m; + updateUrlState(); + if (machines.length > 0) doPlot(); + }, metric || undefined, { placeholder: true }); + if (!metric) metric = initial; + }).catch(() => { + metricLoading.remove(); + metricGroup.append(el('p', { class: 'error-banner' }, 'Failed to load fields')); + }); + + // Test filter + const filterGroup = el('div', { class: 'control-group' }); + filterGroup.append(el('label', {}, 'Filter tests')); + const filterInput = el('input', { + type: 'text', + class: 'test-filter-input', + placeholder: 'Filter tests...', + }) as HTMLInputElement; + filterInput.value = testFilter; + filterInput.addEventListener('input', debounce(() => { + testFilter = filterInput.value.trim(); + if (testFilter) autoCapped = false; + renderFromAllCaches(); + updateUrlState(); + }, 200) as EventListener); + filterGroup.append(filterInput); + controlsRow.append(filterGroup); + + // Aggregation controls + const runAggGroup = el('div', { class: 'control-group' }); + runAggGroup.append(el('label', {}, 'Run aggregation')); + const runAggSelect = el('select', { class: 'agg-select' }) as HTMLSelectElement; + for (const a of ['median', 'mean', 'min', 'max']) { + const opt = el('option', { value: a }, a); + if (a === runAgg) (opt as HTMLOptionElement).selected = true; + runAggSelect.append(opt); + } + runAggSelect.addEventListener('change', () => { + runAgg = runAggSelect.value as AggFn; + renderFromAllCaches(); + updateUrlState(); + }); + runAggGroup.append(runAggSelect); + controlsRow.append(runAggGroup); + + const sampleAggGroup = el('div', { class: 'control-group' }); + sampleAggGroup.append(el('label', {}, 'Sample aggregation')); + const sampleAggSelect = el('select', { class: 'agg-select' }) as HTMLSelectElement; + for (const a of ['median', 'mean', 'min', 'max']) { + const opt = el('option', { value: a }, a); + if (a === sampleAgg) (opt as HTMLOptionElement).selected = true; + sampleAggSelect.append(opt); + } + sampleAggSelect.addEventListener('change', () => { + sampleAgg = sampleAggSelect.value as AggFn; + renderFromAllCaches(); + updateUrlState(); + }); + sampleAggGroup.append(sampleAggSelect); + controlsRow.append(sampleAggGroup); + + // ----- Controls Row 2: Machines + Pinned Orders (side by side) ----- + const secondRow = el('div', { class: 'graph-controls' }); + controlsPanel.append(secondRow); + + // Machine chip input + const machineGroup = el('div', { class: 'control-group' }); + machineGroup.append(el('label', {}, 'Machines')); + const machineInputContainer = el('div', {}); + const machineChipsEl = el('div', { class: 'chip-list', style: 'margin-top: 4px' }); + machineGroup.append(machineInputContainer, machineChipsEl); + + function renderMachineChips(): void { + machineChipsEl.replaceChildren(); + for (const m of machines) { + const idx = machines.indexOf(m); + const symbolChar = assignSymbolChar(idx); + const chip = el('span', { class: 'chip' }, `${symbolChar} ${m}`); + const removeBtn = el('button', { class: 'chip-remove' }, '\u00d7'); + removeBtn.addEventListener('click', () => { + abortForMachine(m); + machines = machines.filter(x => x !== m); + machineScaffolds.delete(m); + for (const key of [...cache.keys()]) { + if (key.startsWith(m + '::')) cache.delete(key); + } + renderMachineChips(); + rebuildSuggestions(); + if (machines.length > 0 && metric) { + doPlot(); + } else { + // No machines left — show empty state + renderFromAllCaches(); + } + updateUrlState(); + }); + chip.append(removeBtn); + machineChipsEl.append(chip); + } + } + + const machineHandle = renderMachineCombobox(machineInputContainer, { + testsuite: ts, + initialValue: '', + onSelect: (name) => { + if (name && !machines.includes(name)) { + machines.push(name); + renderMachineChips(); + machineHandle.clear(); + if (metric) doPlot(); + updateUrlState(); + } + }, + }); + machineComboCleanup = machineHandle.destroy; + renderMachineChips(); + secondRow.append(machineGroup); + + // Pinned Orders (same row as Machines) + const pinGroup = el('div', { class: 'control-group' }); + pinGroup.append(el('label', {}, 'Pinned Orders')); + const pinSearchContainer = el('div', {}); + const pinChips = el('div', { class: 'chip-list', style: 'margin-top: 4px' }); + pinGroup.append(pinSearchContainer, pinChips); + secondRow.append(pinGroup); + + const pinSearchHandle = renderOrderSearch(pinSearchContainer, { + testsuite: ts, + placeholder: 'Pin an order...', + suggestions: cachedSuggestions ?? [], + onSelect: (value) => { + if (!pinnedOrders.find(r => r.value === value)) { + const tag = cachedSuggestions?.find(s => s.orderValue === value)?.tag ?? null; + pinnedOrders.push({ value, tag }); + renderPinChips(); + renderFromAllCaches(); + updateUrlState(); + } + }, + }); + orderSearchCleanup = pinSearchHandle.destroy; + + renderPinChips(); + + function renderPinChips(): void { + pinChips.replaceChildren(); + for (const ref of pinnedOrders) { + const chip = el('span', { class: 'chip' }, + ref.tag ? `${ref.value} (${ref.tag})` : ref.value, + ); + const removeBtn = el('button', { class: 'chip-remove' }, '\u00d7'); + removeBtn.addEventListener('click', () => { + const idx = pinnedOrders.indexOf(ref); + if (idx >= 0) pinnedOrders.splice(idx, 1); + renderPinChips(); + renderFromAllCaches(); + updateUrlState(); + }); + chip.append(removeBtn); + pinChips.append(chip); + } + } + + container.append(progressContainer, warningContainer, chartContainer); + const legendContainer = el('div', { class: 'legend-container' }); + container.append(legendContainer); + + // ----- Hover sync ----- + cleanupTableHover = onCustomEvent<string | null>(GRAPH_TABLE_HOVER, (tn) => { + if (chartHandle) chartHandle.hoverTrace(tn); + }); + cleanupChartHover = onCustomEvent<string | null>(GRAPH_CHART_HOVER, (tn) => { + if (legendHandle) legendHandle.highlightRow(tn); + }); + + // ----- Scaffold suggestions ----- + function rebuildSuggestions(): void { + const scaffold = computeScaffoldUnion(); + if (!scaffold) { + cachedSuggestions = []; + pinSearchHandle.setSuggestions([]); + return; + } + // Fetch tags (cached after first fetch to avoid repeated full-pagination calls) + const ordersPromise = cachedOrders + ? Promise.resolve(cachedOrders) + : getOrders(ts).then(orders => { cachedOrders = orders; return orders; }); + ordersPromise.then(allOrders => { + const tagMap = new Map<string, string | null>(); + for (const o of allOrders) { + tagMap.set(primaryOrderValue(o.fields), o.tag ?? null); + } + const suggestions: OrderSuggestion[] = scaffold.map(ov => ({ + orderValue: ov, + tag: tagMap.get(ov) ?? null, + })); + suggestions.sort((a, b) => { + if (a.tag && !b.tag) return -1; + if (!a.tag && b.tag) return 1; + return 0; + }); + cachedSuggestions = suggestions; + pinSearchHandle.setSuggestions(suggestions); + // Backfill tags for any pinned orders that were added before suggestions loaded + let tagsUpdated = false; + for (const pin of pinnedOrders) { + if (!pin.tag) { + const match = suggestions.find(s => s.orderValue === pin.value); + if (match?.tag) { pin.tag = match.tag; tagsUpdated = true; } + } + } + if (tagsUpdated) renderPinChips(); + }).catch(() => { /* ok */ }); + } + + // ----- Lazy loading (per machine) ----- + + function startLazyLoad(testsuite: string, machineName: string, metricName: string): void { + const key = cacheKey(machineName, metricName); + const existingAbort = metricAborts.get(key); + if (existingAbort) existingAbort.abort(); + + const ctrl = new AbortController(); + metricAborts.set(key, ctrl); + + const entry = getOrCreateCache(machineName, metricName); + if (entry.complete || entry.loading) return; + entry.loading = true; + + (async () => { + try { + while (!entry.complete) { + if (ctrl.signal.aborted) break; + + const params: Record<string, string> = { + machine: machineName, + metric: metricName, + sort: '-order', + limit: PAGE_LIMIT, + }; + if (entry.nextCursor) params.cursor = entry.nextCursor; + + const page = await fetchOneCursorPage<QueryDataPoint>( + apiUrl(testsuite, 'query'), params, ctrl.signal, + ); + + entry.points.push(...page.items); + entry.nextCursor = page.nextCursor; + if (!entry.hasInitialData) entry.hasInitialData = true; + if (!page.nextCursor) entry.complete = true; + + // Re-render if this machine is still selected and metric matches + if (machines.includes(machineName) && metricName === metric) { + renderFromAllCaches(false); + } + } + + // Fetch missing reference order data after loading completes + if (!ctrl.signal.aborted && machines.includes(machineName) && metricName === metric) { + await fetchMissingPinData(testsuite, machineName, metricName, entry, ctrl.signal); + } + } catch (e: unknown) { + if (e instanceof DOMException && e.name === 'AbortError') return; + if (machines.includes(machineName) && metricName === metric) { + warningContainer.replaceChildren( + el('p', { class: 'error-banner' }, `Failed to load data for ${machineName}: ${e}`), + ); + } + } finally { + entry.loading = false; + } + })(); + } + + // ----- Render from all machines' caches ----- + + function renderFromAllCaches(batch = true): void { + // Collect data from all machines + const allChronological: Array<{ machine: string; points: QueryDataPoint[] }> = []; + let anyHasData = false; + let allComplete = true; + let totalPoints = 0; + + for (const m of machines) { + const entry = cache.get(cacheKey(m, metric)); + if (entry?.hasInitialData) { + anyHasData = true; + const chronological = [...entry.points].reverse(); + allChronological.push({ machine: m, points: chronological }); + totalPoints += entry.points.length; + if (!entry.complete) allComplete = false; + } else { + allComplete = false; + } + } + + if (!anyHasData) { + // No data yet — show empty chart with scaffold if available, clear legend + progressContainer.replaceChildren(); + if (legendHandle) { legendHandle.update([], undefined); } + const scaffold = computeScaffoldUnion(); + chartRenderGen++; + if (pendingChartRAF !== null) { + cancelAnimationFrame(pendingChartRAF); + pendingChartRAF = null; + } + const chartOpts = { + traces: [] as TimeSeriesTrace[], + yAxisLabel: metric || '', + categoryOrder: scaffold ?? undefined, + }; + if (chartHandle) { + chartHandle.update(chartOpts); + } else if (scaffold) { + chartHandle = createTimeSeriesChart(chartContainer, chartOpts); + } + return; + } + + // Collect all unique test names across all machines (for color assignment) + const allTestNames = new Set<string>(); + for (const { points } of allChronological) { + for (const pt of points) allTestNames.add(pt.test); + } + const sortedTestNames = [...allTestNames].sort((a, b) => a.localeCompare(b)); + + // Assign colors by test name (same test on different machines = same color) + const colorMap = new Map<string, string>(); + sortedTestNames.forEach((name, i) => colorMap.set(name, assignColor(i))); + + // Build traces per machine with marker symbols + const allTraces: TimeSeriesTrace[] = []; + const allTraceNames: string[] = []; + + for (let mi = 0; mi < machines.length; mi++) { + const m = machines[mi]; + const symbol = assignSymbol(mi); + const machineData = allChronological.find(d => d.machine === m); + if (!machineData) continue; + + const activePoints = machineData.points; + const machineTraces = buildTraces(activePoints, '', runAgg, sampleAgg); + for (const t of machineTraces) { + const tn = traceName(t.testName, m); + allTraces.push({ + ...t, + machine: m, + color: colorMap.get(t.testName), + markerSymbol: symbol, + }); + allTraceNames.push(tn); + } + } + + // Sort all trace names for consistent ordering + allTraceNames.sort((a, b) => a.localeCompare(b)); + + // Filter visible trace names (filter matches on test name portion only) + const lf = testFilter.toLowerCase(); + const visibleTraceNames = testFilter + ? allTraceNames.filter(tn => testNameFromTrace(tn).toLowerCase().includes(lf)) + : allTraceNames; + currentVisibleTraceNames = visibleTraceNames; + + // Compute active set + const activeSet = computeActiveTests(allTraceNames, testFilter, manuallyHidden, autoCapped); + + // Filter traces to only active ones + const activeTraces = allTraces + .filter(t => activeSet.has(traceName(t.testName, t.machine))) + .sort((a, b) => traceName(a.testName, a.machine).localeCompare(traceName(b.testName, b.machine))); + + // --- Synchronous phase: legend table + progress --- + + const legendEntries: LegendEntry[] = visibleTraceNames.map(tn => { + const testN = testNameFromTrace(tn); + // Extract machine name from trace name (after the separator) + const sepIdx = tn.lastIndexOf(TRACE_SEP); + const machN = sepIdx >= 0 ? tn.slice(sepIdx + TRACE_SEP.length) : undefined; + const machIdx = machN ? machines.indexOf(machN) : -1; + return { + testName: tn, + color: colorMap.get(testN) || '#999', + active: activeSet.has(tn), + machineName: machN, + symbolChar: machIdx >= 0 ? assignSymbolChar(machIdx) : undefined, + }; + }); + + // Message + const capActive = autoCapped && !testFilter && manuallyHidden.size === 0 + && allTraceNames.length > DEFAULT_CAP; + let legendMessage: string | undefined; + if (capActive) { + legendMessage = `Showing first ${DEFAULT_CAP} of ${allTraceNames.length} traces. Use the test filter or click rows to see specific traces.`; + } else if (visibleTraceNames.length < allTraceNames.length) { + legendMessage = `${visibleTraceNames.length} of ${allTraceNames.length} traces matching`; + } else if (allTraceNames.length > 0) { + legendMessage = `${allTraceNames.length} traces`; + } + + if (legendHandle) { + legendHandle.update(legendEntries, legendMessage); + } else { + legendHandle = createLegendTable(legendContainer, { + entries: legendEntries, + message: legendMessage, + onToggle: (tn) => { + autoCapped = false; + if (manuallyHidden.has(tn)) { + manuallyHidden.delete(tn); + } else { + manuallyHidden.add(tn); + } + renderFromAllCaches(); + }, + onIsolate: (tn) => { + autoCapped = false; + const othersAllHidden = currentVisibleTraceNames.every( + n => n === tn || manuallyHidden.has(n), + ); + if (othersAllHidden) { + manuallyHidden = new Set(); + } else { + manuallyHidden = new Set(currentVisibleTraceNames.filter(n => n !== tn)); + } + renderFromAllCaches(); + }, + }); + } + + // Progress + if (allComplete) { + progressContainer.replaceChildren(); + } else { + progressContainer.replaceChildren( + el('span', { class: 'progress-label' }, `Loading ${totalPoints} samples...`), + ); + } + + // --- Deferred chart update phase --- + // + // Skip the chart update entirely when the active trace set hasn't changed + // and this is a user-initiated change (batch=true). This avoids unnecessary + // Plotly.react() calls when e.g. typing more characters into the filter + // that still match the same set of tests. + if (batch && setsEqual(activeSet, prevActiveTraceNames)) { + return; + } + prevActiveTraceNames = new Set(activeSet); + + chartRenderGen++; + const myGen = chartRenderGen; + if (pendingChartRAF !== null) { + cancelAnimationFrame(pendingChartRAF); + pendingChartRAF = null; + } + + // Collect all chronological points for reference orders and raw values + const allPoints: QueryDataPoint[] = []; + for (const { points } of allChronological) { + for (const pt of points) allPoints.push(pt); + } + + const refs = buildRefsFromCache(allPoints, pinnedOrders, getAggFn(runAgg)); + const scaffold = computeScaffoldUnion(); + + const rawValuesCallback = (testName: string, machineName: string, orderValue: string): number[] => { + const values: number[] = []; + for (const pt of allPoints) { + if (pt.test === testName && pt.machine === machineName && primaryOrderValue(pt.order) === orderValue) { + values.push(pt.value); + } + } + return values; + }; + + function renderAllTraces(): void { + pendingChartRAF = null; + if (myGen !== chartRenderGen) return; + + const chartOpts = { + traces: activeTraces, + yAxisLabel: metric, + pinnedOrders: refs.length > 0 ? refs : undefined, + categoryOrder: scaffold ?? undefined, + getRawValues: rawValuesCallback, + }; + + if (chartHandle) { + chartHandle.update(chartOpts); + } else { + chartHandle = createTimeSeriesChart(chartContainer, chartOpts); + } + } + + if (!batch) { + // Progressive data loading: render all traces in a single deferred frame. + // No batching here to avoid the batch sequence being repeatedly canceled + // by rapid page arrivals. + if (activeTraces.length === 0) { + renderAllTraces(); + } else { + pendingChartRAF = requestAnimationFrame(renderAllTraces); + } + } else { + // User-initiated change (filter, toggle, aggregation, pinned orders): + // render traces in batches of CHART_BATCH_SIZE per animation frame. + // This batching prevents the browser from freezing when a filter matches + // thousands of tests and the 20-cap is disabled — the chart achieves + // eventual consistency while the UI stays responsive. + let batchEnd = 0; + + function renderNextBatch(): void { + pendingChartRAF = null; + if (myGen !== chartRenderGen) return; + + batchEnd = Math.min(batchEnd + CHART_BATCH_SIZE, activeTraces.length); + const batchTraces = activeTraces.slice(0, batchEnd); + + const chartOpts = { + traces: batchTraces, + yAxisLabel: metric, + pinnedOrders: refs.length > 0 ? refs : undefined, + categoryOrder: scaffold ?? undefined, + getRawValues: rawValuesCallback, + }; + + if (chartHandle) { + chartHandle.update(chartOpts); + } else { + chartHandle = createTimeSeriesChart(chartContainer, chartOpts); + } + + if (batchEnd < activeTraces.length) { + pendingChartRAF = requestAnimationFrame(renderNextBatch); + } + } + + if (activeTraces.length === 0) { + renderNextBatch(); + } else { + pendingChartRAF = requestAnimationFrame(renderNextBatch); + } + } + } + + // ----- Reference orders ----- + + async function fetchMissingPinData( + testsuite: string, + machineName: string, + metricName: string, + entry: MetricCache, + signal: AbortSignal, + ): Promise<void> { + for (const pin of pinnedOrders) { + const hasData = entry.points.some(pt => primaryOrderValue(pt.order) === pin.value); + if (hasData || !pin.value) continue; + + try { + const pinPoints = await queryDataPoints(testsuite, { + machine: machineName, metric: metricName, + afterOrder: pin.value, beforeOrder: pin.value, + }, signal); + if (pinPoints.length > 0) { + entry.points.push(...pinPoints); + if (machines.includes(machineName) && metricName === metric) { + renderFromAllCaches(false); + } + } + } catch { /* ref order may not exist */ } + } + } + + // ----- Scaffold fetching (per machine) ----- + + async function fetchScaffold(testsuite: string, machineName: string): Promise<void> { + if (machineScaffolds.has(machineName)) return; + const signal = scaffoldAbort?.signal; + try { + const seen = new Set<string>(); + const orders: string[] = []; + let cursor: string | undefined; + const runsUrl = apiUrl(testsuite, `machines/${encodeURIComponent(machineName)}/runs`); + while (true) { + if (signal?.aborted) return; + if (!machines.includes(machineName)) return; + const params: Record<string, string> = { sort: 'order', limit: '10000' }; + if (cursor) params.cursor = cursor; + const page = await fetchOneCursorPage<MachineRunInfo>(runsUrl, params, signal); + for (const run of page.items) { + const ov = primaryOrderValue(run.order); + if (!seen.has(ov)) { seen.add(ov); orders.push(ov); } + } + if (!page.nextCursor) break; + cursor = page.nextCursor; + } + if (!machines.includes(machineName)) return; + machineScaffolds.set(machineName, orders); + } catch (e: unknown) { + if (e instanceof DOMException && e.name === 'AbortError') return; + /* scaffold is optional */ + } + } + + // ----- Plot handler ----- + + function doPlot(): void { + if (machines.length === 0 || !metric) { + chartContainer.replaceChildren( + el('p', { class: 'no-chart-data' }, 'No data to plot.'), + ); + return; + } + + warningContainer.replaceChildren(); + + // For each machine, ensure scaffold and data fetching are running + const plotMetric = metric; + const plotMachines = [...machines]; + + (async () => { + // Fetch scaffolds for any machines that don't have one yet + await Promise.all(plotMachines.map(m => fetchScaffold(ts, m))); + + // Rebuild suggestions after scaffolds load + rebuildSuggestions(); + + // Render empty chart with scaffold if available + const scaffold = computeScaffoldUnion(); + if (plotMetric === metric && scaffold) { + if (!chartHandle) { + chartHandle = createTimeSeriesChart(chartContainer, { + traces: [] as TimeSeriesTrace[], + yAxisLabel: plotMetric, + categoryOrder: scaffold, + }); + } + progressContainer.replaceChildren( + el('span', { class: 'progress-label' }, 'Loading data...'), + ); + } + + // Start lazy loading for each machine + for (const m of plotMachines) { + if (machines.includes(m) && plotMetric === metric) { + const entry = getOrCreateCache(m, plotMetric); + if (entry.hasInitialData) { + // Already have data — render immediately + renderFromAllCaches(false); + if (!entry.complete && !entry.loading) { + startLazyLoad(ts, m, plotMetric); + } + } else if (!entry.loading) { + startLazyLoad(ts, m, plotMetric); + } + } + } + })(); + + updateUrlState(); + } + + function updateUrlState(): void { + const qs = new URLSearchParams(); + for (const m of machines) qs.append('machine', m); + qs.set('metric', metric); + if (testFilter) qs.set('test_filter', testFilter); + if (runAgg !== 'median') qs.set('run_agg', runAgg); + if (sampleAgg !== 'median') qs.set('sample_agg', sampleAgg); + for (const ref of pinnedOrders) qs.append('pin', ref.value); + window.history.replaceState(null, '', window.location.pathname + '?' + qs.toString()); + } + + // Auto-plot if machines and metric provided via URL + if (machines.length > 0 && metric) { + doPlot(); + } + }, + + unmount(): void { + if (machineComboCleanup) { machineComboCleanup(); machineComboCleanup = null; } + if (orderSearchCleanup) { orderSearchCleanup(); orderSearchCleanup = null; } + if (scaffoldAbort) { scaffoldAbort.abort(); scaffoldAbort = null; } + abortAllMetrics(); + if (pendingChartRAF !== null) { cancelAnimationFrame(pendingChartRAF); pendingChartRAF = null; } + if (chartHandle) { chartHandle.destroy(); chartHandle = null; } + if (legendHandle) { legendHandle.destroy(); legendHandle = null; } + if (cleanupTableHover) { cleanupTableHover(); cleanupTableHover = null; } + if (cleanupChartHover) { cleanupChartHover(); cleanupChartHover = null; } + manuallyHidden = new Set(); + autoCapped = true; + currentVisibleTraceNames = []; + prevActiveTraceNames = new Set(); + chartRenderGen = 0; + cachedSuggestions = null; + // Intentionally preserve cache and machineScaffolds across + // unmount/remount so that navigating back renders instantly from + // cache. The machines list is restored from URL on mount. + }, +}; + +/** + * Group raw query data points into traces, applying test filter and aggregation. + * Exported for testing. + */ +export function buildTraces( + points: QueryDataPoint[], + testFilter: string, + runAgg: AggFn, + _sampleAgg: AggFn, +): TimeSeriesTrace[] { + // Group by test name + const testMap = new Map<string, QueryDataPoint[]>(); + for (const pt of points) { + if (testFilter && !pt.test.toLowerCase().includes(testFilter.toLowerCase())) continue; + let arr = testMap.get(pt.test); + if (!arr) { arr = []; testMap.set(pt.test, arr); } + arr.push(pt); + } + + const aggFn = getAggFn(runAgg); + const traces: TimeSeriesTrace[] = []; + + for (const [testName, testPoints] of testMap) { + // Group by order value + const orderMap = new Map<string, QueryDataPoint[]>(); + for (const pt of testPoints) { + const ov = primaryOrderValue(pt.order); + let arr = orderMap.get(ov); + if (!arr) { arr = []; orderMap.set(ov, arr); } + arr.push(pt); + } + + const tracePoints: TimeSeriesTrace['points'] = []; + for (const [orderValue, orderPoints] of orderMap) { + const values = orderPoints.map(p => p.value); + tracePoints.push({ + orderValue, + value: aggFn(values), + runCount: orderPoints.length, + timestamp: orderPoints[0].timestamp, + }); + } + + // Machine is set by the caller (renderFromAllCaches) after buildTraces returns + traces.push({ testName, machine: '', points: tracePoints }); + } + + traces.sort((a, b) => a.testName.localeCompare(b.testName)); + return traces; +} + +/** + * Build PinnedOrder objects from cached data points, applying aggregation. + * Exported for testing. + */ +export function buildRefsFromCache( + points: QueryDataPoint[], + refs: Array<{ value: string; tag: string | null }>, + aggFn: (values: number[]) => number, +): PinnedOrder[] { + return refs.map((ref, i) => { + // Collect all raw values per test at this order + const rawPerTest = new Map<string, number[]>(); + for (const pt of points) { + if (primaryOrderValue(pt.order) === ref.value) { + let arr = rawPerTest.get(pt.test); + if (!arr) { arr = []; rawPerTest.set(pt.test, arr); } + arr.push(pt.value); + } + } + // Aggregate using the same function as the main traces + const values = new Map<string, number>(); + for (const [test, raw] of rawPerTest) { + values.set(test, aggFn(raw)); + } + return { + orderValue: ref.value, + tag: ref.tag, + values, + color: PIN_COLORS[i % PIN_COLORS.length], + }; + }); +} diff --git a/lnt/server/ui/v5/frontend/src/pages/machine-detail.ts b/lnt/server/ui/v5/frontend/src/pages/machine-detail.ts new file mode 100644 index 000000000..ab9345f7d --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/pages/machine-detail.ts @@ -0,0 +1,131 @@ +// pages/machine-detail.ts — Machine metadata and run history. + +import type { PageModule, RouteParams } from '../router'; +import type { MachineRunInfo } from '../types'; +import { getMachine, getMachineRuns, deleteMachine } from '../api'; +import { navigate } from '../router'; +import { el, spaLink, formatTime, truncate, primaryOrderValue } from '../utils'; +import { renderDataTable } from '../components/data-table'; +import { renderPagination } from '../components/pagination'; +import { renderDeleteConfirm } from '../components/delete-confirm'; + +const PAGE_SIZE = 25; + +let controller: AbortController | null = null; + +export const machineDetailPage: PageModule = { + mount(container: HTMLElement, params: RouteParams): void { + if (controller) controller.abort(); + controller = new AbortController(); + const { signal } = controller; + + const ts = params.testsuite; + const name = params.name; + + container.append(el('h2', { class: 'page-header' }, `Machine: ${name}`)); + + const metaContainer = el('div', {}); + const actionsContainer = el('div', { class: 'action-links' }); + const runsContainer = el('div', {}); + const deleteContainer = el('div', { class: 'delete-machine-section' }); + container.append(metaContainer, actionsContainer, runsContainer, deleteContainer); + + // Load metadata + getMachine(ts, name, signal).then(machine => { + const entries = Object.entries(machine.info || {}); + if (entries.length > 0) { + const dl = el('dl', { class: 'metadata-dl' }); + for (const [k, v] of entries) { + dl.append(el('dt', {}, k), el('dd', {}, v)); + } + metaContainer.append(dl); + } else { + metaContainer.append(el('p', { class: 'no-results' }, 'No metadata available.')); + } + }).catch(e => { + metaContainer.append(el('p', { class: 'error-banner' }, `Failed to load machine: ${e}`)); + }); + + // Action links + actionsContainer.append( + spaLink('View Graph', `/graph?machine=${encodeURIComponent(name)}`), + spaLink('Compare', `/compare?machine_a=${encodeURIComponent(name)}`), + ); + for (const a of actionsContainer.querySelectorAll('a')) { + a.classList.add('action-link'); + } + + // Load runs with cursor-stack pagination + const cursorStack: string[] = []; + let currentCursor: string | undefined; + + async function loadRuns(): Promise<void> { + runsContainer.replaceChildren(); + runsContainer.append(el('h3', {}, 'Run History')); + runsContainer.append(el('p', { class: 'progress-label' }, 'Loading runs...')); + + try { + const result = await getMachineRuns(ts, name, { + sort: '-start_time', + limit: PAGE_SIZE, + cursor: currentCursor, + }, signal); + + runsContainer.replaceChildren(); + runsContainer.append(el('h3', {}, 'Run History')); + + const tableDiv = el('div', {}); + renderDataTable(tableDiv, { + columns: [ + { key: 'uuid', label: 'Run UUID', + render: (r: MachineRunInfo) => spaLink(r.uuid.slice(0, 8), `/runs/${encodeURIComponent(r.uuid)}`) }, + { key: 'order', label: 'Order', + render: (r: MachineRunInfo) => { + const ov = primaryOrderValue(r.order); + return spaLink(truncate(ov, 12), `/orders/${encodeURIComponent(ov)}`); + } }, + { key: 'start_time', label: 'Start Time', + render: (r: MachineRunInfo) => formatTime(r.start_time) }, + ], + rows: result.items, + emptyMessage: 'No runs found.', + }); + runsContainer.append(tableDiv); + + const paginationDiv = el('div', {}); + renderPagination(paginationDiv, { + hasPrevious: cursorStack.length > 0, + hasNext: result.cursor.next !== null, + onPrevious: () => { currentCursor = cursorStack.pop(); loadRuns(); }, + onNext: () => { + cursorStack.push(currentCursor || ''); + currentCursor = result.cursor.next!; + loadRuns(); + }, + }); + runsContainer.append(paginationDiv); + } catch (e: unknown) { + runsContainer.replaceChildren(); + runsContainer.append(el('h3', {}, 'Run History')); + runsContainer.append(el('p', { class: 'error-banner' }, `Failed to load runs: ${e}`)); + } + } + + loadRuns(); + + // Delete section + renderDeleteConfirm(deleteContainer, { + label: 'Delete Machine', + prompt: `Type "${name}" to confirm deletion. This will delete all runs and data for this machine.`, + confirmValue: name, + placeholder: 'Machine name', + deletingMessage: 'This may take a while for machines with many runs.', + onDelete: () => deleteMachine(ts, name), + onSuccess: () => navigate('/machines'), + }); + }, + + unmount(): void { + if (controller) { controller.abort(); controller = null; } + }, +}; diff --git a/lnt/server/ui/v5/frontend/src/pages/machine-list.ts b/lnt/server/ui/v5/frontend/src/pages/machine-list.ts new file mode 100644 index 000000000..8e75a2657 --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/pages/machine-list.ts @@ -0,0 +1,106 @@ +// pages/machine-list.ts — Searchable machine list with offset pagination. + +import type { PageModule, RouteParams } from '../router'; +import type { MachineInfo } from '../types'; +import { getMachines } from '../api'; +import { el, spaLink, debounce } from '../utils'; +import { renderDataTable } from '../components/data-table'; +import { renderPagination } from '../components/pagination'; + +const PAGE_SIZE = 25; + +let controller: AbortController | null = null; + +export const machineListPage: PageModule = { + mount(container: HTMLElement, params: RouteParams): void { + if (controller) controller.abort(); + controller = new AbortController(); + const { signal } = controller; + + const ts = params.testsuite; + container.append(el('h2', { class: 'page-header' }, 'Machines')); + + // Search input + const searchRow = el('div', { class: 'table-controls' }); + const searchInput = el('input', { + type: 'text', + class: 'test-filter-input', + placeholder: 'Filter by name...', + }) as HTMLInputElement; + + const urlSearch = new URLSearchParams(window.location.search).get('search') || ''; + searchInput.value = urlSearch; + searchRow.append(searchInput); + container.append(searchRow); + + const tableContainer = el('div', {}); + const paginationContainer = el('div', {}); + container.append(tableContainer, paginationContainer); + + let currentOffset = 0; + let currentSearch = urlSearch; + + async function loadPage(): Promise<void> { + tableContainer.replaceChildren(); + paginationContainer.replaceChildren(); + tableContainer.append(el('p', { class: 'progress-label' }, 'Loading machines...')); + + try { + const result = await getMachines(ts, { + nameContains: currentSearch || undefined, + limit: PAGE_SIZE, + offset: currentOffset, + }, signal); + + tableContainer.replaceChildren(); + + renderDataTable(tableContainer, { + columns: [ + { key: 'name', label: 'Name', + render: (m: MachineInfo) => spaLink(m.name, `/machines/${encodeURIComponent(m.name)}`) }, + { key: 'info', label: 'Info', sortable: false, + render: (m: MachineInfo) => formatInfo(m) }, + ], + rows: result.items, + emptyMessage: 'No machines found.', + }); + + const start = currentOffset + 1; + const end = currentOffset + result.items.length; + if (result.total > 0) { + renderPagination(paginationContainer, { + hasPrevious: currentOffset > 0, + hasNext: end < result.total, + rangeText: `${start}\u2013${end} of ${result.total}`, + onPrevious: () => { currentOffset = Math.max(0, currentOffset - PAGE_SIZE); loadPage(); }, + onNext: () => { currentOffset += PAGE_SIZE; loadPage(); }, + }); + } + } catch (e: unknown) { + tableContainer.replaceChildren(); + tableContainer.append(el('p', { class: 'error-banner' }, `Failed to load machines: ${e}`)); + } + } + + const onSearchChange = debounce(() => { + currentSearch = searchInput.value.trim(); + currentOffset = 0; + const qs = currentSearch ? `?search=${encodeURIComponent(currentSearch)}` : ''; + window.history.replaceState(null, '', window.location.pathname + qs); + loadPage(); + }, 300); + + searchInput.addEventListener('input', onSearchChange as EventListener); + loadPage(); + }, + + unmount(): void { + if (controller) { controller.abort(); controller = null; } + }, +}; + +function formatInfo(m: MachineInfo): string { + const entries = Object.entries(m.info || {}); + if (entries.length === 0) return ''; + return entries.slice(0, 3).map(([k, v]) => `${k}: ${v}`).join(', '); +} diff --git a/lnt/server/ui/v5/frontend/src/pages/order-detail.ts b/lnt/server/ui/v5/frontend/src/pages/order-detail.ts new file mode 100644 index 000000000..8a3978be9 --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/pages/order-detail.ts @@ -0,0 +1,181 @@ +// pages/order-detail.ts — Order detail with tag editing, prev/next, machine filter, runs table. + +import type { PageModule, RouteParams } from '../router'; +import type { RunInfo, OrderDetail } from '../types'; +import { getOrder, getRunsByOrder, updateOrderTag, authErrorMessage } from '../api'; +import { el, spaLink, formatTime, primaryOrderValue, debounce } from '../utils'; +import { navigate } from '../router'; +import { renderDataTable } from '../components/data-table'; + +let controller: AbortController | null = null; + +export const orderDetailPage: PageModule = { + mount(container: HTMLElement, params: RouteParams): void { + if (controller) controller.abort(); + controller = new AbortController(); + const { signal } = controller; + + const ts = params.testsuite; + const orderValue = params.value; + + container.append(el('h2', { class: 'page-header' }, `Order: ${orderValue}`)); + + const fieldsContainer = el('div', { class: 'order-fields' }); + const tagContainer = el('div', { class: 'tag-display' }); + const navContainer = el('div', { class: 'order-nav' }); + const summaryContainer = el('div', {}); + const filterContainer = el('div', { class: 'table-controls' }); + const tableContainer = el('div', {}); + container.append( + fieldsContainer, tagContainer, navContainer, + summaryContainer, filterContainer, tableContainer, + ); + + const loading = el('p', { class: 'progress-label' }, 'Loading order data...'); + container.append(loading); + + let runs: RunInfo[] = []; + let machineFilter = ''; + + Promise.all([ + getOrder(ts, orderValue, signal), + getRunsByOrder(ts, orderValue, signal), + ]).then(([order, orderRuns]) => { + loading.remove(); + runs = orderRuns; + + // Order fields + const dl = el('dl', { class: 'metadata-dl' }); + for (const [k, v] of Object.entries(order.fields)) { + dl.append(el('dt', {}, k), el('dd', {}, v || '')); + } + fieldsContainer.append(dl); + + // Tag display + edit + renderTag(tagContainer, ts, orderValue, order); + + // Prev/Next navigation + if (order.previous_order) { + const prevValue = primaryOrderValue(order.previous_order.fields); + const prevBtn = el('button', { class: 'pagination-btn' }, '\u2190 Previous'); + prevBtn.addEventListener('click', () => navigate(`/orders/${encodeURIComponent(prevValue)}`)); + navContainer.append(prevBtn); + } + if (order.next_order) { + const nextValue = primaryOrderValue(order.next_order.fields); + const nextBtn = el('button', { class: 'pagination-btn' }, 'Next \u2192'); + nextBtn.addEventListener('click', () => navigate(`/orders/${encodeURIComponent(nextValue)}`)); + navContainer.append(nextBtn); + } + + // Machine filter + const filterInput = el('input', { + type: 'text', + class: 'test-filter-input', + placeholder: 'Filter machines...', + }) as HTMLInputElement; + const doFilter = debounce(() => { + machineFilter = filterInput.value.toLowerCase(); + renderSummaryAndTable(); + }, 200); + filterInput.addEventListener('input', () => doFilter()); + filterContainer.append(filterInput); + + renderSummaryAndTable(); + }).catch(e => { + loading.remove(); + container.append(el('p', { class: 'error-banner' }, `Failed to load order: ${e}`)); + }); + + function filteredRuns(): RunInfo[] { + if (!machineFilter) return runs; + return runs.filter(r => r.machine.toLowerCase().includes(machineFilter)); + } + + function renderSummaryAndTable(): void { + const visible = filteredRuns(); + const allMachines = new Set(runs.map(r => r.machine)); + const visibleMachines = new Set(visible.map(r => r.machine)); + + summaryContainer.replaceChildren(); + if (machineFilter && visible.length !== runs.length) { + summaryContainer.append(el('p', {}, + `${visible.length} of ${runs.length} run${runs.length !== 1 ? 's' : ''} across ${visibleMachines.size} of ${allMachines.size} machine${allMachines.size !== 1 ? 's' : ''}` + )); + } else { + summaryContainer.append(el('p', {}, + `${runs.length} run${runs.length !== 1 ? 's' : ''} across ${allMachines.size} machine${allMachines.size !== 1 ? 's' : ''}` + )); + } + + tableContainer.replaceChildren(); + renderDataTable(tableContainer, { + columns: [ + { key: 'machine', label: 'Machine', + render: (r: RunInfo) => spaLink(r.machine, `/machines/${encodeURIComponent(r.machine)}`) }, + { key: 'uuid', label: 'Run UUID', + render: (r: RunInfo) => spaLink(r.uuid.slice(0, 8), `/runs/${encodeURIComponent(r.uuid)}`) }, + { key: 'start_time', label: 'Start Time', + render: (r: RunInfo) => formatTime(r.start_time) }, + ], + rows: visible, + emptyMessage: machineFilter ? 'No runs matching filter.' : 'No runs at this order.', + }); + } + }, + + unmount(): void { + if (controller) { controller.abort(); controller = null; } + }, +}; + +function renderTag( + container: HTMLElement, + ts: string, + orderValue: string, + order: OrderDetail, +): void { + container.replaceChildren(); + + const tagLabel = el('strong', {}, 'Tag: '); + const tagValue = el('span', {}, order.tag || '(none)'); + const editBtn = el('button', { class: 'pagination-btn' }, 'Edit'); + container.append(tagLabel, tagValue, editBtn); + + editBtn.addEventListener('click', () => { + container.replaceChildren(); + container.append(el('strong', {}, 'Tag: ')); + + const input = el('input', { + type: 'text', + class: 'tag-edit-input combobox-input', + placeholder: 'Enter tag (max 64 chars)...', + maxlength: '64', + }) as HTMLInputElement; + input.value = order.tag || ''; + input.style.width = '200px'; + + const saveBtn = el('button', { class: 'compare-btn' }, 'Save') as HTMLButtonElement; + const cancelBtn = el('button', { class: 'pagination-btn' }, 'Cancel'); + const errorEl = el('span', { class: 'error-banner', style: 'display:inline;margin-left:8px;padding:4px 8px' }); + + container.append(input, saveBtn, cancelBtn, errorEl); + input.focus(); + + cancelBtn.addEventListener('click', () => renderTag(container, ts, orderValue, order)); + + saveBtn.addEventListener('click', async () => { + saveBtn.disabled = true; + errorEl.textContent = ''; + const newTag = input.value.trim() || null; + try { + const updated = await updateOrderTag(ts, orderValue, newTag); + order.tag = updated.tag; + renderTag(container, ts, orderValue, order); + } catch (e: unknown) { + errorEl.textContent = authErrorMessage(e); + saveBtn.disabled = false; + } + }); + }); +} diff --git a/lnt/server/ui/v5/frontend/src/pages/regression-detail.ts b/lnt/server/ui/v5/frontend/src/pages/regression-detail.ts new file mode 100644 index 000000000..d7071206f --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/pages/regression-detail.ts @@ -0,0 +1,13 @@ +import type { PageModule, RouteParams } from '../router'; +import { el } from '../utils'; + +export const regressionDetailPage: PageModule = { + mount(container: HTMLElement, params: RouteParams): void { + container.append( + el('div', { class: 'page-placeholder' }, + el('h2', {}, `Regression: ${params.uuid}`), + el('p', {}, 'Not implemented yet.'), + ) + ); + }, +}; diff --git a/lnt/server/ui/v5/frontend/src/pages/regression-list.ts b/lnt/server/ui/v5/frontend/src/pages/regression-list.ts new file mode 100644 index 000000000..15d5f6eed --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/pages/regression-list.ts @@ -0,0 +1,13 @@ +import type { PageModule, RouteParams } from '../router'; +import { el } from '../utils'; + +export const regressionListPage: PageModule = { + mount(container: HTMLElement, _params: RouteParams): void { + container.append( + el('div', { class: 'page-placeholder' }, + el('h2', {}, 'Regression List'), + el('p', {}, 'Not implemented yet.'), + ) + ); + }, +}; diff --git a/lnt/server/ui/v5/frontend/src/pages/run-detail.ts b/lnt/server/ui/v5/frontend/src/pages/run-detail.ts new file mode 100644 index 000000000..b3b2aa63d --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/pages/run-detail.ts @@ -0,0 +1,193 @@ +// pages/run-detail.ts — Single run metadata, samples table with progressive +// loading, test filter, metric selector, and run deletion. + +import type { PageModule, RouteParams } from '../router'; +import type { SampleInfo } from '../types'; +import { getRun, getFields, deleteRun, fetchOneCursorPage, apiUrl } from '../api'; +import { el, spaLink, formatValue, formatTime, primaryOrderValue, debounce } from '../utils'; +import { navigate } from '../router'; +import { renderDataTable } from '../components/data-table'; +import { renderMetricSelector, filterMetricFields } from '../components/metric-selector'; +import { renderDeleteConfirm } from '../components/delete-confirm'; + +/** Instance-scoped abort controller for the current mount's sample fetches. */ +let activeFetchController: AbortController | null = null; + +export const runDetailPage: PageModule = { + mount(container: HTMLElement, params: RouteParams): void { + // Abort any in-flight fetches from a previous mount before creating a new controller. + if (activeFetchController) activeFetchController.abort(); + activeFetchController = new AbortController(); + + const ts = params.testsuite; + const uuid = params.uuid; + + container.append(el('h2', { class: 'page-header' }, `Run: ${uuid.slice(0, 8)}\u2026`)); + + const metaContainer = el('div', {}); + const actionsContainer = el('div', { class: 'action-links' }); + const controlsContainer = el('div', { class: 'global-controls' }); + const filterContainer = el('div', { class: 'table-controls' }); + const summaryContainer = el('div', {}); + const tableContainer = el('div', {}); + const deleteContainer = el('div', { class: 'delete-machine-section' }); + container.append( + metaContainer, actionsContainer, controlsContainer, + filterContainer, summaryContainer, tableContainer, deleteContainer, + ); + + const loading = el('p', { class: 'progress-label' }, 'Loading run data...'); + container.append(loading); + + let allSamples: SampleInfo[] = []; + let currentMetric = ''; + let testFilter = ''; + let machineName = ''; + + Promise.all([ + getRun(ts, uuid), + getFields(ts), + ]).then(([run, fields]) => { + loading.remove(); + machineName = run.machine; + + // Metadata + const dl = el('dl', { class: 'metadata-dl' }); + dl.append(el('dt', {}, 'UUID'), el('dd', {}, run.uuid)); + + const machineDd = el('dd', {}); + machineDd.append(spaLink(run.machine, `/machines/${encodeURIComponent(run.machine)}`)); + dl.append(el('dt', {}, 'Machine'), machineDd); + + const orderValue = primaryOrderValue(run.order); + const orderDd = el('dd', {}); + orderDd.append(spaLink(orderValue, `/orders/${encodeURIComponent(orderValue)}`)); + dl.append(el('dt', {}, 'Order'), orderDd); + + dl.append(el('dt', {}, 'Start Time'), el('dd', {}, formatTime(run.start_time))); + dl.append(el('dt', {}, 'End Time'), el('dd', {}, formatTime(run.end_time))); + + for (const [k, v] of Object.entries(run.parameters || {})) { + dl.append(el('dt', {}, k), el('dd', {}, v)); + } + metaContainer.append(dl); + + // Actions + actionsContainer.append( + spaLink( + 'Compare with\u2026', + `/compare?machine_a=${encodeURIComponent(run.machine)}&order_a=${encodeURIComponent(orderValue)}&runs_a=${encodeURIComponent(uuid)}`, + ), + ); + for (const a of actionsContainer.querySelectorAll('a')) { + a.classList.add('action-link'); + } + + // Metric selector + currentMetric = renderMetricSelector(controlsContainer, filterMetricFields(fields), (metric) => { + currentMetric = metric; + renderSamplesTable(); + }); + + // Test filter + const filterInput = el('input', { + type: 'text', + class: 'test-filter-input', + placeholder: 'Filter tests...', + }) as HTMLInputElement; + const doFilter = debounce(() => { + testFilter = filterInput.value.toLowerCase(); + renderSamplesTable(); + }, 200); + filterInput.addEventListener('input', () => doFilter()); + filterContainer.append(filterInput); + + // Progressive sample loading + loadSamplesProgressively(ts, uuid); + + // Delete section + const shortUuid = uuid.slice(0, 8); + renderDeleteConfirm(deleteContainer, { + label: 'Delete Run', + prompt: `Type "${shortUuid}" to confirm deletion. This will delete the run and all its samples.`, + confirmValue: shortUuid, + placeholder: 'Run UUID prefix', + onDelete: () => deleteRun(ts, uuid), + onSuccess: () => navigate(`/machines/${encodeURIComponent(machineName)}`), + }); + }).catch(e => { + loading.remove(); + container.append(el('p', { class: 'error-banner' }, `Failed to load run: ${e}`)); + }); + + async function loadSamplesProgressively(tsName: string, runUuid: string): Promise<void> { + const { signal } = activeFetchController!; + const progressEl = el('p', { class: 'progress-label' }, 'Loading samples...'); + summaryContainer.append(progressEl); + + let cursor: string | null = null; + try { + do { + const params: Record<string, string> = { limit: '2000' }; + if (cursor) params.cursor = cursor; + const page = await fetchOneCursorPage<SampleInfo>( + apiUrl(tsName, `runs/${encodeURIComponent(runUuid)}/samples`), + params, + signal, + ); + allSamples.push(...page.items); + cursor = page.nextCursor; + progressEl.textContent = `Loading samples: ${allSamples.length}${cursor ? '...' : ''}`; + renderSamplesTable(); + } while (cursor); + } catch (err) { + if (err instanceof DOMException && err.name === 'AbortError') return; + summaryContainer.replaceChildren( + el('p', { class: 'error-banner' }, `Failed to load samples: ${err}`), + ); + return; + } + progressEl.remove(); + } + + let filterMessage: HTMLElement | null = null; + + function filteredSamples(): SampleInfo[] { + if (!testFilter) return allSamples; + return allSamples.filter(s => s.test.toLowerCase().includes(testFilter)); + } + + function renderSamplesTable(): void { + const visible = filteredSamples(); + + if (filterMessage) { filterMessage.remove(); filterMessage = null; } + if (testFilter && visible.length !== allSamples.length) { + filterMessage = el('p', { class: 'table-message' }, + `${visible.length} of ${allSamples.length} samples matching`); + summaryContainer.prepend(filterMessage); + } + + tableContainer.replaceChildren(); + renderDataTable(tableContainer, { + columns: [ + { key: 'test', label: 'Test', cellClass: 'col-test', + render: (s: SampleInfo) => s.test }, + { key: 'value', label: 'Value', cellClass: 'col-num', + render: (s: SampleInfo) => formatValue(s.metrics[currentMetric] !== undefined ? s.metrics[currentMetric] : null), + sortValue: (s: SampleInfo) => s.metrics[currentMetric] ?? null }, + ], + rows: visible, + sortKey: 'test', + sortDir: 'asc', + emptyMessage: testFilter ? 'No samples matching filter.' : 'No samples found.', + }); + } + }, + + unmount(): void { + if (activeFetchController) { + activeFetchController.abort(); + activeFetchController = null; + } + }, +}; diff --git a/lnt/server/ui/v5/frontend/src/router.ts b/lnt/server/ui/v5/frontend/src/router.ts new file mode 100644 index 000000000..8add93c17 --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/router.ts @@ -0,0 +1,172 @@ +// router.ts — Client-side URL routing using the History API. + +export interface PageModule { + /** Render the page into the container. Called on navigation. */ + mount(container: HTMLElement, params: RouteParams): void | Promise<void>; + /** Clean up when navigating away. Optional. */ + unmount?(): void; +} + +export interface RouteParams { + testsuite: string; + /** Named captures from the route pattern, e.g. { name: "machine-1" } */ + [key: string]: string; +} + +interface RouteEntry { + /** Regex compiled from the route pattern */ + regex: RegExp; + /** Named group keys in order */ + keys: string[]; + /** The page module to mount */ + module: PageModule; +} + +const routes: RouteEntry[] = []; +let currentModule: PageModule | null = null; +let appContainer: HTMLElement | null = null; +let basePath = ''; // e.g. "/v5/nts" +let onAfterResolve: ((routePath: string) => void) | null = null; + +/** + * Return the current base path (e.g. "/v5/nts"). + * Used by spaLink to construct real href attributes for accessibility. + */ +export function getBasePath(): string { + return basePath; +} + +/** + * Register a route. Pattern uses Express-style `:param` syntax. + * Example: "/machines/:name" matches "/machines/clang-x86" + */ +export function addRoute(pattern: string, module: PageModule): void { + const keys: string[] = []; + // Convert ":param" to named regex groups + const regexStr = pattern + .replace(/:([a-zA-Z_]+)/g, (_match, key) => { + keys.push(key); + return '([^/]+)'; + }); + routes.push({ + regex: new RegExp('^' + regexStr + '$'), + keys, + module, + }); +} + +/** + * Initialize the router. + * @param container The DOM element to render pages into + * @param tsBasePath The base path, e.g. "/v5/nts" + * @param afterResolve Optional callback after each route resolution (for nav highlighting) + */ +export function initRouter( + container: HTMLElement, + tsBasePath: string, + afterResolve?: (routePath: string) => void, +): void { + appContainer = container; + basePath = tsBasePath; + onAfterResolve = afterResolve || null; + + window.addEventListener('popstate', () => { + resolve(); + }); + + // Initial route resolution + resolve(); +} + +/** + * Navigate to a path (relative to the testsuite base). + * Example: navigate("/machines/clang-x86") + */ +export function navigate(path: string): void { + const fullPath = basePath + path; + window.history.pushState(null, '', fullPath); + resolve(); +} + +/** + * Navigate to a path with query string. + */ +export function navigateWithQuery(path: string, query: string): void { + const fullPath = basePath + path; + const qs = query ? '?' + query : ''; + window.history.pushState(null, '', fullPath + qs); + resolve(); +} + +/** + * Resolve the current URL to a route and mount the corresponding page. + */ +function resolve(): void { + if (!appContainer) return; + + const pathname = window.location.pathname; + // Strip basePath prefix to get the route portion + let routePath = pathname; + if (pathname.startsWith(basePath)) { + routePath = pathname.slice(basePath.length); + } + // Ensure it starts with / + if (!routePath.startsWith('/')) { + routePath = '/' + routePath; + } + // Normalize: strip trailing slash (except for root "/") + if (routePath.length > 1 && routePath.endsWith('/')) { + routePath = routePath.slice(0, -1); + } + + // Root path "/" maps to the dashboard + if (routePath === '' || routePath === '/') { + routePath = '/'; + } + + for (const route of routes) { + const match = routePath.match(route.regex); + if (match) { + const params: RouteParams = { + testsuite: basePath.split('/').pop() || '', + }; + route.keys.forEach((key, i) => { + params[key] = decodeURIComponent(match[i + 1]); + }); + + // Unmount previous page + if (currentModule?.unmount) { + currentModule.unmount(); + } + + // Clear container + appContainer.replaceChildren(); + + // Mount new page + currentModule = route.module; + currentModule.mount(appContainer, params); + + if (onAfterResolve) { + onAfterResolve(routePath); + } + return; + } + } + + // No route matched — show 404 + if (currentModule?.unmount) { + currentModule.unmount(); + } + currentModule = null; + appContainer.replaceChildren(); + const msg = document.createElement('div'); + msg.style.padding = '40px'; + msg.style.textAlign = 'center'; + msg.style.color = '#666'; + msg.innerHTML = '<h2>Page Not Found</h2><p>The URL does not match any v5 page.</p>'; + appContainer.appendChild(msg); + + if (onAfterResolve) { + onAfterResolve(''); + } +} diff --git a/lnt/server/ui/v5/frontend/src/selection.ts b/lnt/server/ui/v5/frontend/src/selection.ts new file mode 100644 index 000000000..a90ffff1f --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/selection.ts @@ -0,0 +1,328 @@ +import type { AggFn, FieldInfo, OrderSummary, SideSelection } from './types'; +import { SETTINGS_CHANGE, TEST_FILTER_CHANGE } from './events'; +import { getRuns } from './api'; +import { getState, setSideA, setSideB, setState, swapSides } from './state'; +import { debounce, el } from './utils'; +import { + createOrderCombobox, createMachineCombobox, resetComboboxState, + type ComboboxContext, +} from './combobox'; +import { renderMetricSelector, filterMetricFields } from './components/metric-selector'; + +// Cached data +let cachedOrders: OrderSummary[] = []; +let cachedOrderValues: string[] = []; // primary order values, computed once +let cachedFields: FieldInfo[] = []; +let testsuite = ''; +let onCompare: (() => void) | null = null; + +// Staleness counters for createRunsPanel — prevents earlier async calls +// from overwriting the DOM when a newer call has been issued. +let runsPanelVersionA = 0; +let runsPanelVersionB = 0; + +export function setCachedData( + orders: OrderSummary[], + fields: FieldInfo[], + ts: string, + compareFn?: () => void, +): void { + cachedOrders = orders; + cachedFields = fields; + testsuite = ts; + if (compareFn) onCompare = compareFn; + + // Pre-compute primary order values + cachedOrderValues = []; + for (const o of cachedOrders) { + const keys = Object.keys(o.fields); + if (keys.length > 0) { + cachedOrderValues.push(o.fields[keys[0]]); + } + } +} + +export function getMetricFields(): FieldInfo[] { + return filterMetricFields(cachedFields); +} + +function getSideState(side: 'a' | 'b') { + const state = getState(); + return { + selection: side === 'a' ? state.sideA : state.sideB, + setSide: side === 'a' ? setSideA : setSideB, + label: side === 'a' ? 'Side A (Baseline)' : 'Side B (New)', + }; +} + +function getComboboxContext(): ComboboxContext { + const orderTags = new Map<string, string | null>(); + for (const o of cachedOrders) { + const keys = Object.keys(o.fields); + if (keys.length > 0) { + orderTags.set(o.fields[keys[0]], o.tag ?? null); + } + } + return { + cachedOrderValues, + orderTags, + testsuite, + getSideState, + }; +} + +/** Auto-trigger comparison when state is valid (both sides have runs + metric). */ +function tryAutoCompare(): void { + const state = getState(); + if (state.sideA.runs.length > 0 + && state.sideB.runs.length > 0 + && state.metric !== '' + && onCompare) { + onCompare(); + } +} + +/** + * Debounced version of tryAutoCompare, used only in checkbox change handlers. + * When the user rapidly toggles multiple run checkboxes, the calls coalesce + * into a single comparison after a short delay, avoiding redundant API calls. + */ +const debouncedTryAutoCompare = debounce(tryAutoCompare, 150); + +function createRunsPanel(side: 'a' | 'b', container: HTMLElement, setSide: (partial: Partial<SideSelection>) => void): void { + // Increment the version counter for this side so any in-flight request + // from a previous call knows it is stale and should not touch the DOM. + const version = side === 'a' ? ++runsPanelVersionA : ++runsPanelVersionB; + + container.replaceChildren(el('span', { class: 'runs-hint' }, 'Select order and machine first')); + + const { selection: sideState } = getSideState(side); + + if (!sideState.order || !sideState.machine) return; + + container.replaceChildren(el('span', { class: 'runs-loading' }, 'Loading runs...')); + + getRuns(testsuite, { machine: sideState.machine, order: sideState.order }) + .then(runs => { + // A newer createRunsPanel call was made while we were waiting — + // discard this stale result to avoid overwriting fresh data. + const currentVersion = side === 'a' ? runsPanelVersionA : runsPanelVersionB; + if (version !== currentVersion) return; + container.replaceChildren(); + if (runs.length === 0) { + container.append(el('span', { class: 'runs-empty' }, 'No runs found')); + setSide({ runs: [] }); + return; + } + + // If the URL state has run UUIDs that match available runs, restore + // that selection (some runs may be unchecked). Otherwise select all. + const urlRuns = new Set(sideState.runs); + const hasUrlMatch = runs.some(r => urlRuns.has(r.uuid)); + + for (const run of runs) { + const id = `run-${side}-${run.uuid}`; + const cb = el('input', { type: 'checkbox', id, value: run.uuid }); + cb.checked = hasUrlMatch ? urlRuns.has(run.uuid) : true; + const label = el('label', { for: id }, + run.start_time ? new Date(run.start_time).toLocaleString() : '(no time)', + ' ', + el('span', { class: 'run-uuid' }, `UUID ${run.uuid.slice(0, 8)}`), + ); + container.append(el('div', { class: 'run-row' }, cb, label)); + + cb.addEventListener('change', () => { + const checked = container.querySelectorAll<HTMLInputElement>('input:checked'); + setSide({ runs: Array.from(checked).map(c => c.value) }); + updateRunAggState(side); + debouncedTryAutoCompare(); + }); + } + + const checked = container.querySelectorAll<HTMLInputElement>('input:checked'); + setSide({ runs: Array.from(checked).map(c => c.value) }); + updateRunAggState(side); + tryAutoCompare(); + }) + .catch(e => { + if (e instanceof DOMException && e.name === 'AbortError') return; + container.replaceChildren(el('span', { class: 'runs-error' }, 'Error loading runs')); + }); +} + +let runAggSelectA: HTMLSelectElement | null = null; +let runAggSelectB: HTMLSelectElement | null = null; + +function updateRunAggState(side: 'a' | 'b'): void { + const sel = side === 'a' ? runAggSelectA : runAggSelectB; + if (!sel) return; + const { selection } = getSideState(side); + sel.disabled = selection.runs.length <= 1; +} + +function createRunAggSelect( + side: 'a' | 'b', + setSide: (partial: Partial<SideSelection>) => void, +): HTMLSelectElement { + const { selection } = getSideState(side); + const select = el('select', { class: 'agg-select' }) as HTMLSelectElement; + for (const v of ['median', 'mean', 'min', 'max'] as AggFn[]) { + const opt = el('option', { value: v }, v); + if (v === selection.runAgg) (opt as HTMLOptionElement).selected = true; + select.append(opt); + } + select.disabled = true; + select.addEventListener('change', () => { + setSide({ runAgg: select.value as AggFn }); + tryAutoCompare(); + }); + if (side === 'a') runAggSelectA = select; + else runAggSelectB = select; + return select; +} + +function createSampleAggSelect(): HTMLSelectElement { + const state = getState(); + const select = el('select', { class: 'agg-select' }) as HTMLSelectElement; + for (const v of ['median', 'mean', 'min', 'max'] as AggFn[]) { + const opt = el('option', { value: v }, v); + if (v === state.sampleAgg) (opt as HTMLOptionElement).selected = true; + select.append(opt); + } + select.addEventListener('change', () => { + setState({ sampleAgg: select.value as AggFn }); + tryAutoCompare(); + }); + return select; +} + +// Main render +export function renderSelectionPanel(root: HTMLElement): void { + root.replaceChildren(); + resetComboboxState(); + + const panel = el('div', { class: 'controls-panel' }); + + // Side A and B + const sidesRow = el('div', { class: 'sides-row' }); + const runsContainers: Record<string, HTMLElement> = {}; + const ctx = getComboboxContext(); + const sideDivs: HTMLElement[] = []; + + for (const side of ['a', 'b'] as const) { + const { setSide, label } = getSideState(side); + + const sideDiv = el('div', { class: `side side-${side}` }); + sideDiv.append(el('h3', {}, label)); + + const runsContainer = el('div', { class: 'runs-container' }); + runsContainers[side] = runsContainer; + + const refreshRuns = () => createRunsPanel(side, runsContainer, setSide); + + // Machine + sideDiv.append(el('label', {}, 'Machine')); + sideDiv.append(createMachineCombobox(side, setSide, refreshRuns, ctx)); + + // Order + sideDiv.append(el('label', {}, 'Order')); + sideDiv.append(createOrderCombobox(side, setSide, refreshRuns, ctx)); + + // Runs + sideDiv.append(el('label', {}, 'Runs')); + sideDiv.append(runsContainer); + + // Run aggregation + const aggRow = el('div', { class: 'agg-row' }); + aggRow.append(el('label', {}, 'Run aggregation:')); + aggRow.append(createRunAggSelect(side, setSide)); + sideDiv.append(aggRow); + + sideDivs.push(sideDiv); + } + + // Swap button between the two sides + const swapBtn = el('button', { + class: 'swap-sides-btn', + title: 'Swap A and B sides', + 'aria-label': 'Swap A and B sides', + }, '\u21C4'); + swapBtn.addEventListener('click', () => { + swapSides(); + renderSelectionPanel(root); + tryAutoCompare(); + }); + + sidesRow.append(sideDivs[0], swapBtn, sideDivs[1]); + panel.append(sidesRow); + + // Global controls + const globalRow = el('div', { class: 'global-controls' }); + + renderMetricSelector(globalRow, getMetricFields(), (metric) => { + setState({ metric }); + tryAutoCompare(); + }, getState().metric, { placeholder: true }); + + const sampleAggGroup = el('div', { class: 'control-group' }); + sampleAggGroup.append(el('label', {}, 'Sample aggregation')); + sampleAggGroup.append(createSampleAggSelect()); + globalRow.append(sampleAggGroup); + + const noiseGroup = el('div', { class: 'control-group' }); + noiseGroup.append(el('label', {}, 'Noise %')); + const noiseInput = el('input', { + type: 'number', + class: 'noise-input', + value: String(getState().noise), + min: '0', + step: '0.1', + }); + noiseInput.addEventListener('change', () => { + setState({ noise: parseFloat(noiseInput.value) || 0 }); + document.dispatchEvent(new CustomEvent(SETTINGS_CHANGE)); + }); + noiseGroup.append(noiseInput); + globalRow.append(noiseGroup); + + const hideNoiseGroup = el('div', { class: 'control-group control-group-checkbox' }); + const hideNoiseCb = el('input', { type: 'checkbox', id: 'hide-noise' }) as HTMLInputElement; + hideNoiseCb.checked = getState().hideNoise; + hideNoiseCb.addEventListener('change', () => { + setState({ hideNoise: hideNoiseCb.checked }); + document.dispatchEvent(new CustomEvent(SETTINGS_CHANGE)); + }); + hideNoiseGroup.append(hideNoiseCb); + hideNoiseGroup.append(el('label', { for: 'hide-noise' }, 'Hide noise')); + globalRow.append(hideNoiseGroup); + + // Test filter + const filterGroup = el('div', { class: 'control-group' }); + filterGroup.append(el('label', {}, 'Filter tests')); + const filterInput = el('input', { + type: 'text', + class: 'test-filter-input', + placeholder: 'Filter tests...', + value: getState().testFilter, + }); + const doFilter = debounce(() => { + setState({ testFilter: filterInput.value }); + document.dispatchEvent(new CustomEvent(TEST_FILTER_CHANGE)); + }, 200); + filterInput.addEventListener('input', () => doFilter()); + filterGroup.append(filterInput); + globalRow.append(filterGroup); + + panel.append(globalRow); + + root.append(panel); + + // Trigger initial runs load if state has order+machine (use stored references) + const state = getState(); + if (state.sideA.order && state.sideA.machine) { + createRunsPanel('a', runsContainers['a'], setSideA); + } + if (state.sideB.order && state.sideB.machine) { + createRunsPanel('b', runsContainers['b'], setSideB); + } +} diff --git a/lnt/server/ui/v5/frontend/src/state.ts b/lnt/server/ui/v5/frontend/src/state.ts new file mode 100644 index 000000000..faf031b10 --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/state.ts @@ -0,0 +1,150 @@ +import type { AggFn, AppState, SideSelection, SortCol, SortDir } from './types'; + +const DEFAULTS: AppState = { + sideA: { order: '', machine: '', runs: [], runAgg: 'median' }, + sideB: { order: '', machine: '', runs: [], runAgg: 'median' }, + metric: '', + sampleAgg: 'median', + noise: 1, + sort: 'delta_pct', + sortDir: 'desc', + testFilter: '', + hideNoise: false, +}; + +let state: AppState = structuredClone(DEFAULTS); + +export function getState(): AppState { + return state; +} + +export function setState(partial: Partial<AppState>): void { + Object.assign(state, partial); + replaceUrl(); +} + +export function setSideA(partial: Partial<AppState['sideA']>): void { + Object.assign(state.sideA, partial); + replaceUrl(); +} + +export function setSideB(partial: Partial<AppState['sideB']>): void { + Object.assign(state.sideB, partial); + replaceUrl(); +} + +export function swapSides(): void { + const tmp = state.sideA; + state.sideA = state.sideB; + state.sideB = tmp; + replaceUrl(); +} + +const VALID_AGG: AggFn[] = ['median', 'mean', 'min', 'max']; +const VALID_SORT: SortCol[] = ['test', 'value_a', 'value_b', 'delta', 'delta_pct', 'ratio', 'status']; +const VALID_DIR: SortDir[] = ['asc', 'desc']; + +function parseAgg(v: string | null): AggFn | undefined { + return v && VALID_AGG.includes(v as AggFn) ? v as AggFn : undefined; +} + +function decodeSide(p: URLSearchParams, suffix: string): SideSelection | undefined { + const order = p.get(`order_${suffix}`); + const machine = p.get(`machine_${suffix}`); + const runs = p.get(`runs_${suffix}`); + const runAgg = parseAgg(p.get(`run_agg_${suffix}`)); + if (order || machine || runs || runAgg) { + return { + order: order || '', + machine: machine || '', + runs: runs ? runs.split(',').filter(Boolean) : [], + runAgg: runAgg || 'median', + }; + } + return undefined; +} + +function encodeSide(p: URLSearchParams, side: SideSelection, suffix: string): void { + if (side.order) p.set(`order_${suffix}`, side.order); + if (side.machine) p.set(`machine_${suffix}`, side.machine); + if (side.runs.length) p.set(`runs_${suffix}`, side.runs.join(',')); + if (side.runAgg !== 'median') p.set(`run_agg_${suffix}`, side.runAgg); +} + +export function decodeFromUrl(search: string): Partial<AppState> { + const p = new URLSearchParams(search); + const result: Partial<AppState> = {}; + + const sideA = decodeSide(p, 'a'); + if (sideA) result.sideA = sideA; + + const sideB = decodeSide(p, 'b'); + if (sideB) result.sideB = sideB; + + const metric = p.get('metric'); + if (metric) result.metric = metric; + + const sampleAgg = parseAgg(p.get('sample_agg')); + if (sampleAgg) result.sampleAgg = sampleAgg; + + const noise = p.get('noise'); + if (noise !== null) { + const n = parseFloat(noise); + if (Number.isFinite(n) && n >= 0) result.noise = n; + } + + const sort = p.get('sort'); + if (sort && VALID_SORT.includes(sort as SortCol)) result.sort = sort as SortCol; + + const sortDir = p.get('sort_dir'); + if (sortDir && VALID_DIR.includes(sortDir as SortDir)) result.sortDir = sortDir as SortDir; + + const testFilter = p.get('test_filter'); + if (testFilter) result.testFilter = testFilter; + + const hideNoise = p.get('hide_noise'); + if (hideNoise === '1') result.hideNoise = true; + else if (hideNoise === '0') result.hideNoise = false; + + return result; +} + +export function encodeToUrl(s: AppState): string { + const p = new URLSearchParams(); + + encodeSide(p, s.sideA, 'a'); + encodeSide(p, s.sideB, 'b'); + + if (s.metric) p.set('metric', s.metric); + if (s.sampleAgg !== 'median') p.set('sample_agg', s.sampleAgg); + if (s.noise !== 1) p.set('noise', String(s.noise)); + if (s.sort !== 'delta_pct') p.set('sort', s.sort); + if (s.sortDir !== 'desc') p.set('sort_dir', s.sortDir); + if (s.testFilter) p.set('test_filter', s.testFilter); + if (s.hideNoise) p.set('hide_noise', '1'); + + const qs = p.toString(); + return qs ? `?${qs}` : ''; +} + +/** Decode URL params and apply onto a fresh default state. */ +export function applyUrlState(search: string): void { + const decoded = decodeFromUrl(search); + // Reset to defaults first, then apply decoded URL params + state = structuredClone(DEFAULTS); + if (decoded.sideA) state.sideA = { ...state.sideA, ...decoded.sideA }; + if (decoded.sideB) state.sideB = { ...state.sideB, ...decoded.sideB }; + if (decoded.metric !== undefined) state.metric = decoded.metric; + if (decoded.sampleAgg !== undefined) state.sampleAgg = decoded.sampleAgg; + if (decoded.noise !== undefined) state.noise = decoded.noise; + if (decoded.sort !== undefined) state.sort = decoded.sort; + if (decoded.sortDir !== undefined) state.sortDir = decoded.sortDir; + if (decoded.testFilter !== undefined) state.testFilter = decoded.testFilter; + if (decoded.hideNoise !== undefined) state.hideNoise = decoded.hideNoise; +} + +export function replaceUrl(): void { + const qs = encodeToUrl(state); + const url = window.location.pathname + qs; + window.history.replaceState(null, '', url); +} diff --git a/lnt/server/ui/v5/frontend/src/style.css b/lnt/server/ui/v5/frontend/src/style.css new file mode 100644 index 000000000..86df4bc92 --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/style.css @@ -0,0 +1,1131 @@ +/* ============================================================ + v5 SPA — Base / Foundation Styles + ============================================================ + The SPA shell (v5_app.html) is standalone — it does not extend + layout.html and inherits no CSS framework. These rules provide + the typographic baseline and element resets that every page needs. + ============================================================ */ + +*, *::before, *::after { + box-sizing: border-box; +} + +body { + margin: 0; + font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, + "Helvetica Neue", Arial, sans-serif; + font-size: 14px; + line-height: 1.5; + color: #333; + background: #fff; +} + +#v5-app { + max-width: 1200px; + margin: 0 auto; + padding: 12px 20px; +} + +/* Links */ +a { + color: #0d6efd; + text-decoration: none; +} + +a:hover { + text-decoration: underline; +} + +/* Headings */ +h1, h2, h3, h4 { + margin-top: 0; + color: #333; +} + +h2 { font-size: 20px; font-weight: 600; } +h3 { font-size: 15px; font-weight: 600; } + +/* Form elements — match the Compare page's control styling */ +input[type="text"], +input[type="password"], +input[type="search"], +select { + padding: 4px 8px; + border: 1px solid #ccc; + border-radius: 3px; + font-family: inherit; + font-size: 13px; + color: #333; + background: #fff; +} + +input[type="text"]:focus, +input[type="password"]:focus, +input[type="search"]:focus, +select:focus { + outline: none; + border-color: #0d6efd; + box-shadow: 0 0 0 2px rgba(13, 110, 253, 0.15); +} + +button { + font-family: inherit; + font-size: 13px; + cursor: pointer; +} + +/* Tables — base reset (component classes add the rest) */ +table { + border-collapse: collapse; + width: 100%; +} + +/* Utility: definition list (used for metadata on detail pages) */ +dl { + margin: 0; +} + +/* ============================================================ + Shared Controls Panel (used by Compare, Graph, etc.) + ============================================================ */ + +.controls-panel { + padding: 15px; + background: #f8f9fa; + border: 1px solid #dee2e6; + border-radius: 4px; + margin-bottom: 20px; +} + +.sides-row { + display: flex; + gap: 20px; + align-items: flex-start; + margin-bottom: 15px; +} + +.swap-sides-btn { + flex-shrink: 0; + align-self: center; + width: 32px; + height: 32px; + padding: 0; + border: 1px solid #ccc; + border-radius: 50%; + background: #fff; + font-size: 16px; + line-height: 1; + cursor: pointer; + color: #666; +} + +.swap-sides-btn:hover { + background: #e9ecef; + color: #333; + border-color: #adb5bd; +} + +.side { + flex: 1; + background: #fff; + padding: 12px; + border: 1px solid #dee2e6; + border-radius: 4px; +} + +.side h3 { + margin: 0 0 10px 0; + font-size: 14px; + font-weight: 600; + color: #333; +} + +.side label { + display: block; + font-size: 12px; + font-weight: 600; + color: #666; + margin: 8px 0 3px 0; +} + +/* Combobox */ +.combobox { + position: relative; +} + +.combobox-input { + width: 100%; + padding: 4px 8px; + border: 1px solid #ccc; + border-radius: 3px; + font-size: 13px; + box-sizing: border-box; +} + +.combobox-dropdown { + position: absolute; + z-index: 1000; + width: 100%; + max-height: 200px; + overflow-y: auto; + background: #fff; + border: 1px solid #ccc; + border-top: none; + border-radius: 0 0 3px 3px; + list-style: none; + margin: 0; + padding: 0; + display: none; + box-shadow: 0 2px 8px rgba(0,0,0,0.15); +} + +.combobox-dropdown.open { + display: block; +} + +.combobox-item { + padding: 4px 8px; + cursor: pointer; + font-size: 13px; +} + +.combobox-item:hover { + background: #e9ecef; +} + +/* Runs */ +.runs-container { + max-height: 120px; + overflow-y: auto; + border: 1px solid #eee; + border-radius: 3px; + padding: 4px; + background: #fff; +} + +.runs-hint, .runs-loading, .runs-empty, .runs-error { + font-size: 12px; + color: #999; + padding: 4px; +} + +.runs-error { + color: #d62728; +} + +.run-row { + display: flex; + align-items: center; + gap: 6px; + padding: 2px 0; + font-size: 12px; +} + +.run-row input[type="checkbox"] { + margin: 0; +} + +.run-uuid { + color: #888; + font-size: 11px; +} + +/* Aggregation */ +.agg-row { + display: flex; + align-items: center; + gap: 8px; + margin-top: 8px; +} + +.agg-row label { + margin: 0; + display: inline; +} + +.agg-select { + padding: 2px 6px; + border: 1px solid #ccc; + border-radius: 3px; + font-size: 12px; +} + +.agg-select:disabled { + opacity: 0.5; +} + +/* Global Controls */ +.global-controls { + display: flex; + gap: 15px; + align-items: flex-end; + margin-bottom: 12px; + flex-wrap: wrap; +} + +.control-group { + display: flex; + flex-direction: column; + gap: 3px; +} + +.control-group label { + font-size: 12px; + font-weight: 600; + color: #666; +} + +.control-group-checkbox { + flex-direction: row; + align-items: center; + gap: 6px; +} + +.control-group-checkbox label { + margin: 0; +} + +.metric-select { + padding: 4px 8px; + border: 1px solid #ccc; + border-radius: 3px; + font-size: 13px; + min-width: 200px; +} + +.noise-input { + width: 60px; + padding: 4px 6px; + border: 1px solid #ccc; + border-radius: 3px; + font-size: 13px; +} + +/* Action Row */ +.action-row { + display: flex; + gap: 10px; + align-items: center; + margin-bottom: 10px; +} + +.compare-btn { + padding: 6px 20px; + background: #0d6efd; + color: #fff; + border: none; + border-radius: 4px; + font-size: 14px; + font-weight: 600; + cursor: pointer; +} + +.compare-btn:hover:not(:disabled) { + background: #0b5ed7; +} + +.compare-btn:disabled { + background: #6c757d; + cursor: not-allowed; +} + +.settings-toggle { + padding: 4px 12px; + background: none; + border: 1px solid #ccc; + border-radius: 3px; + font-size: 12px; + cursor: pointer; + color: #666; +} + +.settings-panel { + background: #fff; + border: 1px solid #dee2e6; + border-radius: 4px; + padding: 10px; + margin-bottom: 10px; +} + +.settings-panel label { + display: block; + font-size: 12px; + font-weight: 600; + color: #666; + margin-bottom: 4px; +} + +.token-input { + width: 100%; + max-width: 400px; + padding: 4px 8px; + border: 1px solid #ccc; + border-radius: 3px; + font-size: 13px; + box-sizing: border-box; +} + +/* Progress */ +.progress-row { + display: flex; + align-items: center; + gap: 10px; +} + +.progress-label { + font-size: 12px; + color: #666; +} + +/* Error Banner */ +.error-banner { + background: #f8d7da; + color: #842029; + padding: 8px 12px; + border: 1px solid #f5c2c7; + border-radius: 4px; + font-size: 13px; + margin-top: 8px; +} + +/* Results Area */ +#results-root { + margin-top: 15px; +} + +#chart-container { + margin-bottom: 20px; +} + +.no-chart-data { + color: #666; + font-style: italic; + padding: 20px; + text-align: center; +} + +/* Table Controls */ +.table-controls { + display: flex; + gap: 10px; + align-items: center; + margin-bottom: 10px; +} + +.test-filter-input { + padding: 4px 8px; + border: 1px solid #ccc; + border-radius: 3px; + font-size: 13px; + width: 250px; +} + +.reset-filters-btn { + padding: 4px 12px; + background: none; + border: 1px solid #ccc; + border-radius: 3px; + font-size: 12px; + cursor: pointer; + color: #666; +} + +.reset-filters-btn:hover { + background: #f0f0f0; +} + +/* Noise Summary */ +.noise-summary { + padding: 6px 10px; + background: #fff3cd; + border: 1px solid #ffecb5; + border-radius: 4px; + font-size: 13px; + color: #664d03; + margin-bottom: 10px; +} + +.table-message { + padding: 6px 8px; + font-size: 12px; + color: #666; + margin-bottom: 4px; +} + +.noise-summary a { + color: #0d6efd; + text-decoration: underline; +} + +/* Comparison Table */ +.comparison-table { + width: 100%; + border-collapse: collapse; + font-size: 13px; +} + +.comparison-table th { + border-bottom: 2px solid #dee2e6; + padding: 6px 8px; + text-align: left; + font-weight: 600; + font-size: 12px; + color: #495057; + white-space: nowrap; +} + +.comparison-table th.sortable { + cursor: pointer; + user-select: none; +} + +.comparison-table th.sortable:hover { + background: #f0f0f0; +} + +.comparison-table td { + border-bottom: 1px solid #eee; + padding: 4px 8px; +} + +.col-test { + max-width: 400px; + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} + +.col-num { + text-align: right; + font-family: monospace; + white-space: nowrap; +} + +.col-status { + font-weight: 600; + font-size: 12px; + text-transform: uppercase; +} + +/* Status colors */ +.status-improved { + color: #2ca02c; +} + +.status-regressed { + color: #d62728; +} + +.status-noise, .status-unchanged { + color: #999; +} + +.status-missing { + color: #888; + font-style: italic; +} + +.status-na { + color: #888; +} + +/* Row states */ +.row-noise { + opacity: 0.5; +} + +.row-hidden { + opacity: 0.3; +} + +.row-missing { + color: #888; + font-style: italic; +} + +.row-na { + opacity: 0.7; +} + +.row-highlighted { + background: #fff3cd !important; +} + +.comparison-table tbody tr[data-test] { + cursor: pointer; +} + +.comparison-table tbody tr:hover { + background: #f5f5f5; +} + +/* Missing table */ +.missing-header { + margin: 20px 0 8px 0; + font-size: 14px; + color: #666; +} + +.missing-table { + opacity: 0.7; +} + +.no-results { + color: #666; + font-style: italic; + padding: 10px; +} + +/* ============================================================ + v5 SPA Navigation Bar + ============================================================ */ + +.v5-nav { + display: flex; + align-items: center; + gap: 12px; + padding: 8px 15px; + background: #343a40; + border-radius: 4px; + margin-bottom: 15px; + flex-wrap: wrap; +} + +.v5-nav-brand { + color: #fff; + font-weight: 700; + font-size: 16px; + text-decoration: none; + margin-right: 8px; +} + +.v5-nav-brand:hover { + color: #ddd; +} + +.v5-nav-suite { + display: flex; + align-items: center; + gap: 4px; + color: #adb5bd; + font-size: 13px; +} + +.v5-nav-suite-select { + padding: 2px 6px; + border: 1px solid #555; + border-radius: 3px; + background: #495057; + color: #fff; + font-size: 12px; +} + +.v5-nav-links { + display: flex; + gap: 4px; + flex: 1; +} + +.v5-nav-link { + color: #adb5bd; + text-decoration: none; + font-size: 13px; + padding: 4px 10px; + border-radius: 3px; +} + +.v5-nav-link:hover { + color: #fff; + background: #495057; +} + +.v5-nav-link-active { + color: #fff; + background: #0d6efd; +} + +.v5-nav-right { + display: flex; + gap: 4px; + margin-left: auto; +} + +/* Page container */ +#v5-page { + min-height: 300px; +} + +.page-placeholder { + padding: 40px; + text-align: center; + color: #666; +} + +.page-placeholder h2 { + margin-bottom: 10px; +} + +/* ============================================================ + Phase 2: Core Browsing Pages + ============================================================ */ + +/* Pagination controls */ +.pagination-controls { + display: flex; + gap: 10px; + align-items: center; + margin: 10px 0; +} + +.pagination-btn { + padding: 4px 12px; + border: 1px solid #ccc; + border-radius: 3px; + background: #fff; + cursor: pointer; + font-size: 13px; +} + +.pagination-btn:hover:not(:disabled) { + background: #f0f0f0; +} + +.pagination-btn:disabled { + opacity: 0.5; + cursor: not-allowed; +} + +.pagination-range { + font-size: 13px; + color: #666; +} + +/* Dashboard */ +.dashboard-section { + margin-bottom: 20px; +} + +.dashboard-section h3 { + font-size: 15px; + font-weight: 600; + margin-bottom: 8px; + color: #333; +} + +/* Page headers */ +.page-header { + margin: 0 0 15px 0; + font-size: 20px; + color: #333; +} + +/* Metadata definition list */ +.metadata-dl { + display: grid; + grid-template-columns: auto 1fr; + gap: 4px 12px; + margin-bottom: 15px; + font-size: 13px; +} + +.metadata-dl dt { + font-weight: 600; + color: #666; +} + +.metadata-dl dd { + margin: 0; + word-break: break-all; +} + +/* Action links */ +.action-links { + display: flex; + gap: 10px; + margin: 10px 0; +} + +.action-link { + padding: 4px 12px; + border: 1px solid #0d6efd; + color: #0d6efd; + border-radius: 3px; + text-decoration: none; + font-size: 13px; +} + +.action-link:hover { + background: #0d6efd; + color: #fff; +} + +/* Order search */ +.order-search { + position: relative; + display: inline-block; +} + +.order-search-input { + width: 280px; +} + +.order-search-dropdown { + position: absolute; + z-index: 1000; + width: 100%; + max-height: 200px; + overflow-y: auto; + background: #fff; + border: 1px solid #ccc; + border-top: none; + border-radius: 0 0 3px 3px; + list-style: none; + margin: 0; + padding: 0; + display: none; + box-shadow: 0 2px 8px rgba(0,0,0,0.15); +} + +.order-search-dropdown.open { + display: block; +} + +.order-search-tag { + color: #0d6efd; + font-size: 12px; + margin-left: 4px; +} + +.order-search-invalid { + border-color: #d62728 !important; + box-shadow: 0 0 0 2px rgba(214, 39, 40, 0.15) !important; +} + +/* Order detail */ +.order-fields { + margin-bottom: 10px; +} + +.order-nav { + display: flex; + gap: 10px; + margin: 10px 0; +} + +.tag-display { + display: flex; + align-items: center; + gap: 8px; + margin-bottom: 10px; + font-size: 13px; +} + +.tag-edit-input { + padding: 4px 8px; + border: 1px solid #ccc; + border-radius: 3px; + font-size: 13px; +} + +/* Data table tweaks */ +.data-table { + margin-bottom: 10px; +} + +/* ============================================================ + Phase 3: Graph Page + ============================================================ */ + +.graph-controls { + display: flex; + gap: 15px; + align-items: flex-end; + flex-wrap: wrap; + margin-bottom: 12px; +} + +.graph-chart { + min-height: 400px; + margin: 10px 0; +} + +/* Chip lists (machines, pinned orders) */ +.chip-list { + display: flex; + flex-direction: column; + gap: 4px; + margin-top: 6px; + align-items: flex-start; +} + +.chip { + display: inline-flex; + align-items: center; + gap: 4px; + padding: 2px 8px; + background: #e9ecef; + border: 1px solid #dee2e6; + border-radius: 12px; + font-size: 12px; + color: #333; +} + +.chip-remove { + background: none; + border: none; + padding: 0 2px; + font-size: 14px; + cursor: pointer; + color: #666; + line-height: 1; +} + +.chip-remove:hover { + color: #d62728; +} + +/* Legend table (Graph Page) */ +.legend-container { + margin-top: 10px; + border: 1px solid #dee2e6; + border-radius: 4px; +} + +.legend-table { + width: 100%; + border-collapse: collapse; + font-size: 13px; +} + +.legend-table td { + padding: 4px 8px; + border-bottom: 1px solid #eee; + cursor: pointer; + user-select: none; +} + +.legend-table tbody tr:hover { + background: #f5f5f5; +} + +.legend-swatch-cell { + white-space: nowrap; + width: 1%; +} + +.legend-symbol { + font-size: 16px; + vertical-align: middle; + line-height: 1; +} + +.legend-test-name { + /* Left-justified (default) */ +} + +.legend-machine-name { + text-align: right; + color: #888; + font-size: 12px; + white-space: nowrap; + padding-left: 16px; +} + +.legend-row-inactive { + opacity: 0.4; +} + +.legend-message { + padding: 6px 8px; + font-size: 12px; + color: #666; + border-bottom: 1px solid #eee; +} + +.legend-table .row-highlighted { + background: #fff3cd !important; +} + +/* Delete machine section */ +.delete-machine-section { + margin-top: 24px; + padding-top: 16px; + border-top: 1px solid #eee; +} + +.delete-machine-confirm { + margin-top: 8px; +} + +.delete-machine-confirm p { + margin: 0 0 8px 0; + font-size: 13px; + color: #842029; +} + +.delete-machine-confirm .admin-input { + display: block; + margin-bottom: 8px; +} + +/* Admin page */ + +.admin-tabs { + display: flex; + gap: 0; + border-bottom: 2px solid #ddd; + margin-bottom: 16px; +} + +.admin-tab { + padding: 8px 20px; + border: none; + background: none; + cursor: pointer; + font-size: 14px; + color: #555; + border-bottom: 2px solid transparent; + margin-bottom: -2px; +} + +.admin-tab:hover { + color: #333; +} + +.admin-tab-active { + color: #1f77b4; + border-bottom-color: #1f77b4; + font-weight: 600; +} + +.admin-create-form { + margin-bottom: 16px; +} + +.admin-create-form label { + display: block; + font-weight: 600; + margin-bottom: 6px; +} + +.admin-form-row { + display: flex; + gap: 8px; + align-items: center; +} + +.admin-input { + padding: 6px 10px; + border: 1px solid #ccc; + border-radius: 4px; + font-size: 14px; + min-width: 200px; +} + +.admin-select { + padding: 6px 10px; + border: 1px solid #ccc; + border-radius: 4px; + font-size: 14px; +} + +.admin-btn { + padding: 6px 14px; + background: #1f77b4; + color: #fff; + border: none; + border-radius: 4px; + cursor: pointer; + font-size: 14px; +} + +.admin-btn:hover { + background: #1a6da0; +} + +.admin-btn:disabled { + opacity: 0.5; + cursor: not-allowed; +} + +.admin-btn-danger { + background: #d62728; +} + +.admin-btn-danger:hover { + background: #b71c1c; +} + +.admin-key-created { + margin-top: 8px; + padding: 10px; + background: #d4edda; + border: 1px solid #c3e6cb; + border-radius: 4px; +} + +.admin-raw-token { + display: flex; + align-items: center; + gap: 8px; + margin-top: 6px; + padding: 12px 16px; + background: #f0f0f0; + border-radius: 6px; + font-family: monospace; + font-size: 15px; + word-break: break-all; +} + +.admin-raw-token span { + flex: 1; +} + +.admin-token-row { + display: flex; + align-items: center; + gap: 6px; + margin-top: 6px; +} + +.admin-copy-btn { + padding: 0; + border: none; + background: none; + cursor: pointer; + font-size: 16px; + color: #4a90d9; + flex-shrink: 0; +} + +.admin-copy-btn:hover { + color: #1f77b4; +} + +.admin-textarea { + width: 100%; + max-width: 600px; + padding: 8px 10px; + border: 1px solid #ccc; + border-radius: 4px; + font-family: monospace; + font-size: 13px; + margin-top: 8px; + resize: vertical; +} + +.admin-delete-section { + margin-top: 24px; + padding-top: 16px; + border-top: 1px solid #eee; +} + +.admin-delete-confirm { + margin-top: 12px; +} + +.admin-delete-warning { + color: #d62728; + font-weight: 500; + margin-bottom: 8px; +} diff --git a/lnt/server/ui/v5/frontend/src/table.ts b/lnt/server/ui/v5/frontend/src/table.ts new file mode 100644 index 000000000..cdf3db2e2 --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/table.ts @@ -0,0 +1,295 @@ +import type { ComparisonRow, SortCol, SortDir } from './types'; +import { TABLE_HOVER } from './events'; +import { getState, setState } from './state'; +import { formatValue, formatPercent, formatRatio, el } from './utils'; +import { computeGeomean } from './comparison'; + +export interface TableOptions { + /** Test names that are hidden (grayed out in table, excluded from chart). */ + hiddenTests?: Set<string>; + /** Called when a row is single-clicked (toggle visibility). */ + onToggle?: (test: string) => void; + /** Called when a row is double-clicked (isolate — hide all others). */ + onIsolate?: (test: string) => void; +} + +let tableContainer: HTMLElement | null = null; +let allRows: ComparisonRow[] = []; +let filteredTests: Set<string> | null = null; // null = show all +let currentOptions: TableOptions = {}; + +export function renderTable(container: HTMLElement, rows: ComparisonRow[], options?: TableOptions): void { + tableContainer = container; + allRows = rows; + filteredTests = null; + currentOptions = options ?? {}; + redraw(); +} + +export function filterToTests(tests: Set<string> | null): void { + filteredTests = tests; + redraw(); +} + +function redraw(): void { + if (!tableContainer) return; + tableContainer.replaceChildren(); + + const state = getState(); + const { sort, sortDir, testFilter } = state; + const hiddenTests = currentOptions.hiddenTests ?? new Set<string>(); + + // Filter + sort + let rows = [...allRows]; + + // Text filter + if (testFilter) { + const lf = testFilter.toLowerCase(); + rows = rows.filter(r => r.test.toLowerCase().includes(lf)); + } + + // Chart zoom filter + if (filteredTests) { + rows = rows.filter(r => filteredTests!.has(r.test)); + } + + // Separate missing tests + const presentRows = rows.filter(r => r.sidePresent === 'both'); + const missingRows = rows.filter(r => r.sidePresent !== 'both'); + + // Total present tests (before text filter and zoom, but same sidePresent='both') + const totalPresent = allRows.filter(r => r.sidePresent === 'both').length; + const visibleCount = presentRows.filter(r => !hiddenTests.has(r.test)).length; + + // Sort (no hideNoise filtering — hidden rows are shown grayed out) + const sorted = sortRows(presentRows, sort, sortDir); + + // Summary message (like Graph page's "42 of 150 traces matching") + if (totalPresent > 0) { + let message: string; + if (testFilter || filteredTests) { + message = `${visibleCount} of ${totalPresent} tests matching`; + } else if (visibleCount < totalPresent) { + message = `${visibleCount} of ${totalPresent} tests visible`; + } else { + message = `${totalPresent} tests`; + } + tableContainer.append(el('div', { class: 'table-message' }, message)); + } + + // Main table + if (sorted.length > 0) { + tableContainer.append(buildTable(sorted, sort, sortDir, hiddenTests)); + } + + // Missing tests section + if (missingRows.length > 0) { + const missingHeader = el('h4', { class: 'missing-header' }, `Missing tests (${missingRows.length})`); + tableContainer.append(missingHeader); + tableContainer.append(buildMissingTable(missingRows)); + } +} + +function buildTable(rows: ComparisonRow[], sort: SortCol, sortDir: SortDir, hiddenTests: Set<string>): HTMLTableElement { + const table = el('table', { class: 'comparison-table' }) as HTMLTableElement; + + // Header + const thead = el('thead'); + const headerRow = el('tr'); + const cols: { key: SortCol; label: string }[] = [ + { key: 'test', label: 'Test' }, + { key: 'value_a', label: 'Value A' }, + { key: 'value_b', label: 'Value B' }, + { key: 'delta', label: 'Delta' }, + { key: 'delta_pct', label: 'Delta %' }, + { key: 'ratio', label: 'Ratio' }, + { key: 'status', label: 'Status' }, + ]; + + for (const col of cols) { + const isSorted = col.key === sort; + const ariaSortValue = isSorted ? (sortDir === 'asc' ? 'ascending' : 'descending') : 'none'; + const th = el('th', { class: 'sortable', 'aria-sort': ariaSortValue }); + const indicator = isSorted ? (sortDir === 'asc' ? ' \u25B2' : ' \u25BC') : ''; + th.textContent = col.label + indicator; + th.addEventListener('click', () => { + if (sort === col.key) { + setState({ sortDir: sortDir === 'asc' ? 'desc' : 'asc' }); + } else { + setState({ sort: col.key, sortDir: 'desc' }); + } + redraw(); + }); + headerRow.append(th); + } + thead.append(headerRow); + table.append(thead); + + // Body + const tbody = el('tbody'); + + // Geomean summary row (first row) — only visible (non-hidden) rows + const visibleRows = rows.filter(r => !hiddenTests.has(r.test)); + const geomean = computeGeomean(visibleRows); + if (geomean !== null) { + const summaryRow = el('tr', { class: 'geomean-row' }); + summaryRow.append( + el('td', { class: 'col-test' }, el('strong', {}, 'Geomean')), + el('td', { class: 'col-num' }, formatValue(geomean.geomeanA)), + el('td', { class: 'col-num' }, formatValue(geomean.geomeanB)), + el('td', { class: 'col-num' }, formatValue(geomean.delta)), + el('td', { class: 'col-num' }, formatPercent(geomean.deltaPct)), + el('td', { class: 'col-num' }, formatRatio(geomean.ratioGeomean)), + el('td', { class: 'col-status' }, ''), + ); + tbody.append(summaryRow); + } + + for (const row of rows) { + const tr = el('tr', { 'data-test': row.test }); + + if (hiddenTests.has(row.test)) { + tr.classList.add('row-hidden'); + } else if (row.status === 'noise') { + tr.classList.add('row-noise'); + } else if (row.status === 'na') { + tr.classList.add('row-na'); + } + + tr.append(el('td', { class: 'col-test' }, row.test)); + tr.append(el('td', { class: 'col-num' }, formatValue(row.valueA))); + tr.append(el('td', { class: 'col-num' }, formatValue(row.valueB))); + tr.append(el('td', { class: 'col-num' }, formatValue(row.delta))); + tr.append(el('td', { class: 'col-num' }, formatPercent(row.deltaPct))); + tr.append(el('td', { class: 'col-num' }, formatRatio(row.ratio))); + tr.append(el('td', { class: `col-status status-${row.status}` }, row.status)); + + tbody.append(tr); + } + + // Event delegation for hover sync (1 listener instead of 2N) + tbody.addEventListener('mouseenter', (e) => { + const tr = (e.target as HTMLElement).closest('tr[data-test]'); + if (tr) { + document.dispatchEvent(new CustomEvent(TABLE_HOVER, { detail: tr.getAttribute('data-test') })); + } + }, true); + tbody.addEventListener('mouseleave', (e) => { + const tr = (e.target as HTMLElement).closest('tr[data-test]'); + if (tr) { + document.dispatchEvent(new CustomEvent(TABLE_HOVER, { detail: null })); + } + }, true); + + // Click/dblclick for toggle/isolate (200ms delay to distinguish, same as legend table) + if (currentOptions.onToggle || currentOptions.onIsolate) { + let clickTimer: ReturnType<typeof setTimeout> | null = null; + + tbody.addEventListener('click', (e) => { + const tr = (e.target as HTMLElement).closest('tr[data-test]'); + if (!tr) return; + const test = tr.getAttribute('data-test'); + if (!test) return; + + if (clickTimer !== null) return; // dblclick pending + clickTimer = setTimeout(() => { + clickTimer = null; + if (currentOptions.onToggle) currentOptions.onToggle(test); + }, 200); + }); + + tbody.addEventListener('dblclick', (e) => { + const tr = (e.target as HTMLElement).closest('tr[data-test]'); + if (!tr) return; + const test = tr.getAttribute('data-test'); + if (!test) return; + + if (clickTimer !== null) { + clearTimeout(clickTimer); + clickTimer = null; + } + if (currentOptions.onIsolate) currentOptions.onIsolate(test); + }); + } + + table.append(tbody); + return table; +} + +function buildMissingTable(rows: ComparisonRow[]): HTMLTableElement { + const table = el('table', { class: 'comparison-table missing-table' }) as HTMLTableElement; + const thead = el('thead'); + const headerRow = el('tr'); + headerRow.append(el('th', {}, 'Test'), el('th', {}, 'Value A'), el('th', {}, 'Value B'), el('th', {}, 'Present In')); + thead.append(headerRow); + table.append(thead); + + const tbody = el('tbody'); + for (const row of rows) { + const tr = el('tr', { 'data-test': row.test, class: 'row-missing' }); + tr.append(el('td', {}, row.test)); + tr.append(el('td', { class: 'col-num' }, formatValue(row.valueA))); + tr.append(el('td', { class: 'col-num' }, formatValue(row.valueB))); + tr.append(el('td', {}, row.sidePresent === 'a_only' ? 'Side A only' : 'Side B only')); + tbody.append(tr); + } + table.append(tbody); + return table; +} + +export function sortRows(rows: ComparisonRow[], col: SortCol, dir: SortDir): ComparisonRow[] { + const mult = dir === 'asc' ? 1 : -1; + return [...rows].sort((a, b) => { + let av: number | string | null; + let bv: number | string | null; + switch (col) { + case 'test': av = a.test; bv = b.test; break; + case 'value_a': av = a.valueA; bv = b.valueA; break; + case 'value_b': av = a.valueB; bv = b.valueB; break; + case 'delta': av = a.delta; bv = b.delta; break; + case 'delta_pct': av = a.deltaPct; bv = b.deltaPct; break; + case 'ratio': av = a.ratio; bv = b.ratio; break; + case 'status': av = a.status; bv = b.status; break; + } + if (av === null && bv === null) return 0; + if (av === null) return 1; + if (bv === null) return -1; + if (typeof av === 'string' && typeof bv === 'string') { + return av.localeCompare(bv) * mult; + } + return ((av as number) - (bv as number)) * mult; + }); +} + +export function getVisibleTestNames(): Set<string> | null { + if (!tableContainer) return null; + const trs = tableContainer.querySelectorAll<HTMLTableRowElement>('tbody tr[data-test]'); + const names = new Set<string>(); + for (const tr of trs) { + const name = tr.getAttribute('data-test'); + if (name) names.add(name); + } + return names.size > 0 ? names : null; +} + +// External: highlight a row by test name +export function highlightRow(testName: string | null): void { + if (!tableContainer) return; + // Remove previous highlights + for (const el of tableContainer.querySelectorAll('.row-highlighted')) { + el.classList.remove('row-highlighted'); + } + if (!testName) return; + const tr = tableContainer.querySelector(`tr[data-test="${CSS.escape(testName)}"]`); + if (tr) { + tr.classList.add('row-highlighted'); + } +} + +/** Reset module-level state. Call from page unmount. */ +export function resetTable(): void { + tableContainer = null; + allRows = []; + filteredTests = null; + currentOptions = {}; +} diff --git a/lnt/server/ui/v5/frontend/src/types.ts b/lnt/server/ui/v5/frontend/src/types.ts new file mode 100644 index 000000000..d44ffce5e --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/types.ts @@ -0,0 +1,170 @@ +// v5 API response types + +export interface FieldInfo { + name: string; + type: string; + display_name: string | null; + unit: string | null; + unit_abbrev: string | null; + bigger_is_better: boolean | null; +} + +export interface OrderSummary { + fields: Record<string, string>; + tag: string | null; +} + +export interface OrderDetail { + fields: Record<string, string>; + tag: string | null; + previous_order: OrderNeighbor | null; + next_order: OrderNeighbor | null; +} + +export interface OrderNeighbor { + fields: Record<string, string>; + link: string; +} + +export interface MachineInfo { + name: string; + info: Record<string, string>; +} + +export interface RunInfo { + uuid: string; + machine: string; + order: Record<string, string>; + start_time: string | null; + end_time: string | null; + parameters?: Record<string, string>; +} + +/** Run as returned by GET /machines/{name}/runs (no machine or parameters). */ +export interface MachineRunInfo { + uuid: string; + order: Record<string, string>; + start_time: string | null; + end_time: string | null; +} + +export interface RunDetail { + uuid: string; + machine: string; + order: Record<string, string>; + start_time: string | null; + end_time: string | null; + parameters: Record<string, string>; +} + +export interface SampleInfo { + test: string; + has_profile: boolean; + metrics: Record<string, number | null>; +} + +export interface FieldChangeInfo { + uuid: string; + test: string | null; + machine: string | null; + metric: string | null; + old_value: number; + new_value: number; + start_order: string | null; + end_order: string | null; + run_uuid: string | null; +} + +export interface QueryDataPoint { + test: string; + machine: string; + metric: string; + value: number; + order: Record<string, string>; + run_uuid: string; + timestamp: string | null; +} + +export interface CursorPaginated<T> { + items: T[]; + cursor: { + next: string | null; + previous: string | null; + }; +} + +export interface OffsetPaginated<T> { + items: T[]; + total: number; + cursor: { + next: string | null; + previous: string | null; + }; +} + +// App state + +export type AggFn = 'median' | 'mean' | 'min' | 'max'; +export type SortDir = 'asc' | 'desc'; +export type SortCol = 'test' | 'value_a' | 'value_b' | 'delta' | 'delta_pct' | 'ratio' | 'status'; + +export interface SideSelection { + order: string; + machine: string; + runs: string[]; // UUIDs + runAgg: AggFn; +} + +export interface AppState { + sideA: SideSelection; + sideB: SideSelection; + metric: string; + sampleAgg: AggFn; + noise: number; // percentage (e.g. 1 = 1%) + sort: SortCol; + sortDir: SortDir; + testFilter: string; + hideNoise: boolean; +} + +// Comparison results + +export type RowStatus = 'improved' | 'regressed' | 'unchanged' | 'noise' | 'missing' | 'na'; + +export interface ComparisonRow { + test: string; + valueA: number | null; + valueB: number | null; + delta: number | null; + deltaPct: number | null; + ratio: number | null; + status: RowStatus; + sidePresent: 'both' | 'a_only' | 'b_only'; +} + +// Admin types + +export interface APIKeyItem { + prefix: string; + name: string; + scope: string; + created_at: string; + last_used_at: string | null; + is_active: boolean; +} + +export interface APIKeyCreateResponse { + key: string; + prefix: string; + scope: string; +} + +export interface TestSuiteInfo { + name: string; + schema: { + metrics: FieldInfo[]; + run_fields: Array<{ name: string; type: string }>; + order_fields: Array<{ name: string; type: string }>; + machine_fields: Array<{ name: string; type: string }>; + }; +} diff --git a/lnt/server/ui/v5/frontend/src/utils.ts b/lnt/server/ui/v5/frontend/src/utils.ts new file mode 100644 index 000000000..e9c2f65f9 --- /dev/null +++ b/lnt/server/ui/v5/frontend/src/utils.ts @@ -0,0 +1,127 @@ +import type { AggFn } from './types'; +import { navigate, getBasePath } from './router'; + +/** + * Separator between test name and machine name in trace names. + * Uses middle-dot (U+00B7) to avoid ambiguity when machine names contain ' - '. + */ +export const TRACE_SEP = ' \u00b7 '; + +// Aggregation functions + +export function median(values: number[]): number { + if (values.length === 0) return 0; + const sorted = [...values].sort((a, b) => a - b); + const mid = Math.floor(sorted.length / 2); + return sorted.length % 2 !== 0 + ? sorted[mid] + : (sorted[mid - 1] + sorted[mid]) / 2; +} + +export function mean(values: number[]): number { + if (values.length === 0) return 0; + return values.reduce((s, v) => s + v, 0) / values.length; +} + +export function safeMin(values: number[]): number { + if (values.length === 0) return 0; + return values.reduce((a, b) => Math.min(a, b)); +} + +export function safeMax(values: number[]): number { + if (values.length === 0) return 0; + return values.reduce((a, b) => Math.max(a, b)); +} + +export function getAggFn(name: AggFn): (values: number[]) => number { + switch (name) { + case 'median': return median; + case 'mean': return mean; + case 'min': return safeMin; + case 'max': return safeMax; + } +} + +// Formatting + +export function formatValue(v: number | null): string { + if (v === null) return 'N/A'; + if (Math.abs(v) >= 1000) return v.toFixed(1); + if (Math.abs(v) >= 1) return v.toPrecision(4); + if (v === 0) return '0'; + return v.toPrecision(3); +} + +export function formatPercent(v: number | null): string { + if (v === null) return 'N/A'; + const sign = v > 0 ? '+' : ''; + return `${sign}${v.toFixed(2)}%`; +} + +export function formatRatio(v: number | null): string { + if (v === null) return 'N/A'; + return v.toFixed(4); +} + +export function formatTime(iso: string | null, fallback = '\u2014'): string { + if (!iso) return fallback; + try { return new Date(iso).toLocaleString(); } catch { return iso; } +} + +export function truncate(s: string, max: number): string { + return s.length > max ? s.slice(0, max) + '\u2026' : s; +} + +/** Extract the primary (first) order field value from an order fields dict. */ +export function primaryOrderValue(fields: Record<string, string>): string { + return Object.values(fields)[0] || ''; +} + +// DOM helpers + +export function debounce<T extends (...args: unknown[]) => void>(fn: T, ms: number): T { + let timer: ReturnType<typeof setTimeout>; + return ((...args: unknown[]) => { + clearTimeout(timer); + timer = setTimeout(() => fn(...args), ms); + }) as T; +} + +export function el<K extends keyof HTMLElementTagNameMap>( + tag: K, + attrs?: Record<string, string | boolean>, + ...children: (Node | string)[] +): HTMLElementTagNameMap[K] { + const e = document.createElement(tag); + if (attrs) { + for (const [k, v] of Object.entries(attrs)) { + if (v === true) { + e.setAttribute(k, ''); + } else if (v === false) { + // Boolean false: omit the attribute entirely + } else { + e.setAttribute(k, v); + } + } + } + for (const child of children) { + e.append(child); + } + return e; +} + +/** + * Create an anchor element that navigates via the SPA router. + * All internal links across all pages should use this helper. + * + * The href is set to the real full path so that right-click "Open in new tab", + * middle-click, browser status bar, and screen readers all work correctly. + */ +export function spaLink(text: string, path: string): HTMLAnchorElement { + const a = el('a', { href: getBasePath() + path, class: 'spa-link' }, text); + a.addEventListener('click', (e) => { + e.preventDefault(); + navigate(path); + }); + return a; +} diff --git a/lnt/server/ui/v5/frontend/tsconfig.json b/lnt/server/ui/v5/frontend/tsconfig.json new file mode 100644 index 000000000..6d657b2d3 --- /dev/null +++ b/lnt/server/ui/v5/frontend/tsconfig.json @@ -0,0 +1,14 @@ +{ + "compilerOptions": { + "target": "ES2020", + "module": "ESNext", + "moduleResolution": "bundler", + "strict": true, + "noUnusedLocals": true, + "noUnusedParameters": true, + "noFallthroughCasesInSwitch": true, + "isolatedModules": true, + "skipLibCheck": true + }, + "include": ["src"] +} diff --git a/lnt/server/ui/v5/frontend/vite.config.ts b/lnt/server/ui/v5/frontend/vite.config.ts new file mode 100644 index 000000000..380381fd5 --- /dev/null +++ b/lnt/server/ui/v5/frontend/vite.config.ts @@ -0,0 +1,25 @@ +import { defineConfig } from 'vite'; +import { resolve } from 'path'; + +export default defineConfig({ + build: { + outDir: resolve(__dirname, '../static/v5'), + emptyOutDir: true, + sourcemap: true, + lib: { + entry: resolve(__dirname, 'src/main.ts'), + formats: ['iife'], + name: 'LNTv5', + fileName: () => 'v5.js', + }, + rollupOptions: { + external: ['plotly.js-dist'], + output: { + globals: { + 'plotly.js-dist': 'Plotly', + }, + assetFileNames: 'v5[extname]', + }, + }, + }, +}); diff --git a/lnt/server/ui/v5/templates/v5_app.html b/lnt/server/ui/v5/templates/v5_app.html new file mode 100644 index 000000000..d3635e8cf --- /dev/null +++ b/lnt/server/ui/v5/templates/v5_app.html @@ -0,0 +1,20 @@ +<!DOCTYPE html> +<html lang="en"> +<head> + <meta charset="UTF-8"/> + <meta name="viewport" content="width=device-width, initial-scale=1.0"/> + <title>{{ old_config.name }}{% if g.testsuite_name %} : {{ g.testsuite_name }}{% endif %} - v5 UI + + + + + + +
    +
    + + + diff --git a/lnt/server/ui/v5/views.py b/lnt/server/ui/v5/views.py new file mode 100644 index 000000000..585986491 --- /dev/null +++ b/lnt/server/ui/v5/views.py @@ -0,0 +1,42 @@ +from flask import g, render_template, request + +from . import v5_frontend, _setup_testsuite +from lnt.server.ui.views import ts_data +from lnt.server.ui.decorators import _make_db_session + + +@v5_frontend.route("/v5/admin", strict_slashes=False) +def v5_admin(): + """Admin page route — not test-suite specific. + + Serves the SPA shell with an empty testsuite. The admin page + gets the list of available test suites from data-testsuites. + """ + g.testsuite_name = '' + _make_db_session(None) + try: + db = request.get_db() + return render_template("v5_app.html", + testsuites=sorted(db.testsuite.keys())) + finally: + request.session.close() + + +@v5_frontend.route("/v5//") +@v5_frontend.route("/v5//") +def v5_app(testsuite_name, subpath=None): + """Catch-all route for the v5 SPA. + + All client-side routes (dashboard, machines, graph, compare, etc.) + hit this single endpoint, which serves the SPA shell. The TypeScript + router handles the rest. + """ + _setup_testsuite(testsuite_name) + try: + ts = request.get_testsuite() + data = ts_data(ts) + db = request.get_db() + data['testsuites'] = sorted(db.testsuite.keys()) + return render_template("v5_app.html", **data) + finally: + request.session.close() diff --git a/pyproject.toml b/pyproject.toml index c816277db..52e261a1d 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -99,6 +99,12 @@ find = {namespaces = false} "templates/reporting/*.html", "templates/reporting/*.txt", ] +"lnt.server.ui.v5" = [ + "templates/*.html", + "static/v5/*.js", + "static/v5/*.css", + "static/v5/*.map", +] "lnt.server.db" = [ "migrations/*.py" ] @@ -115,7 +121,7 @@ count = true plugins = ["sqlmypy"] [tool.tox] -env_list = ["py3", "mypy", "flake8", "docs"] +env_list = ["py3", "mypy", "flake8", "js", "docs"] [tool.tox.env.py3] description = "Run the unit tests" @@ -132,6 +138,16 @@ deps = [".[dev]"] commands = [["flake8", "--statistics", "--exclude=./lnt/external/", "./lnt/", "./tests/"]] skip_install = true +[tool.tox.env.js] +description = "Run JavaScript/TypeScript tests for the comparison SPA" +allowlist_externals = ["npm"] +commands = [ + ["npm", "--prefix", "lnt/server/ui/v5/frontend", "install"], + ["npm", "--prefix", "lnt/server/ui/v5/frontend", "test"], + ["npm", "--prefix", "lnt/server/ui/v5/frontend", "run", "build"], +] +skip_install = true + [tool.tox.env.mypy] description = "Typecheck the codebase" # TODO: Make it possible to install [.dev] dependencies instead diff --git a/tests/server/ui/v5/test_compare.py b/tests/server/ui/v5/test_compare.py new file mode 100644 index 000000000..7387bdca7 --- /dev/null +++ b/tests/server/ui/v5/test_compare.py @@ -0,0 +1,42 @@ +# Tests for the v5 compare route. +# +# The old standalone compare page (v5_compare.html + comparison.js) was +# replaced by the SPA catch-all in Phase 1. The /v5/{ts}/compare URL +# now serves the SPA shell, and the client-side router handles the +# compare page module. +# +# RUN: rm -rf %t.instance %t.pg.log +# RUN: %{utils}/with_postgres.sh %t.pg.log \ +# RUN: %{utils}/with_temporary_instance.py %t.instance \ +# RUN: -- python %s %t.instance +# END. + +import sys +import unittest + +import lnt.server.ui.app + +INSTANCE_PATH = sys.argv.pop(1) + + +class TestComparePage(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.app = lnt.server.ui.app.App.create_standalone(INSTANCE_PATH) + cls.app.testing = True + cls.client = cls.app.test_client() + + def test_compare_serves_spa_shell(self): + resp = self.client.get('/v5/nts/compare') + self.assertEqual(resp.status_code, 200) + html = resp.get_data(as_text=True) + self.assertIn('id="v5-app"', html) + self.assertIn('data-testsuite="nts"', html) + + def test_compare_nonexistent_testsuite(self): + resp = self.client.get('/v5/nonexistent/compare') + self.assertEqual(resp.status_code, 404) + + +if __name__ == '__main__': + unittest.main() diff --git a/tests/server/ui/v5/test_spa_shell.py b/tests/server/ui/v5/test_spa_shell.py new file mode 100644 index 000000000..a5d82b8a3 --- /dev/null +++ b/tests/server/ui/v5/test_spa_shell.py @@ -0,0 +1,171 @@ +# Tests for the v5 SPA shell (Phase 1). +# Verifies that the catch-all route serves the SPA shell for all v5 routes, +# that the v4 compare route still works, and that the SPA template includes +# the expected elements. +# +# RUN: rm -rf %t.instance %t.pg.log +# RUN: %{utils}/with_postgres.sh %t.pg.log \ +# RUN: %{utils}/with_temporary_instance.py %t.instance \ +# RUN: -- python %s %t.instance +# END. + +import sys +import unittest + +import lnt.server.ui.app + +INSTANCE_PATH = sys.argv.pop(1) + + +class TestSPAShell(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.app = lnt.server.ui.app.App.create_standalone(INSTANCE_PATH) + cls.app.testing = True + cls.client = cls.app.test_client() + + # --- SPA catch-all route --- + + def test_dashboard_route(self): + resp = self.client.get('/v5/nts/') + self.assertEqual(resp.status_code, 200) + html = resp.get_data(as_text=True) + self.assertIn('id="v5-app"', html) + self.assertIn('data-testsuite="nts"', html) + + def test_machines_route(self): + resp = self.client.get('/v5/nts/machines') + self.assertEqual(resp.status_code, 200) + html = resp.get_data(as_text=True) + self.assertIn('id="v5-app"', html) + + def test_machine_detail_route(self): + resp = self.client.get('/v5/nts/machines/some-machine') + self.assertEqual(resp.status_code, 200) + html = resp.get_data(as_text=True) + self.assertIn('id="v5-app"', html) + + def test_runs_route(self): + resp = self.client.get('/v5/nts/runs/some-uuid') + self.assertEqual(resp.status_code, 200) + html = resp.get_data(as_text=True) + self.assertIn('id="v5-app"', html) + + def test_orders_route(self): + resp = self.client.get('/v5/nts/orders/some-value') + self.assertEqual(resp.status_code, 200) + html = resp.get_data(as_text=True) + self.assertIn('id="v5-app"', html) + + def test_graph_route(self): + resp = self.client.get('/v5/nts/graph') + self.assertEqual(resp.status_code, 200) + html = resp.get_data(as_text=True) + self.assertIn('id="v5-app"', html) + + def test_regressions_route(self): + resp = self.client.get('/v5/nts/regressions') + self.assertEqual(resp.status_code, 200) + html = resp.get_data(as_text=True) + self.assertIn('id="v5-app"', html) + + def test_field_changes_route(self): + resp = self.client.get('/v5/nts/field-changes') + self.assertEqual(resp.status_code, 200) + html = resp.get_data(as_text=True) + self.assertIn('id="v5-app"', html) + + def test_admin_subpath_under_testsuite(self): + resp = self.client.get('/v5/nts/admin') + self.assertEqual(resp.status_code, 200) + html = resp.get_data(as_text=True) + self.assertIn('id="v5-app"', html) + + # --- Global admin route (not testsuite-specific) --- + + def test_admin_route(self): + """The /v5/admin route is global, not under any testsuite.""" + resp = self.client.get('/v5/admin') + self.assertEqual(resp.status_code, 200) + html = resp.get_data(as_text=True) + self.assertIn('id="v5-app"', html) + # Admin is suite-independent — testsuite should be empty + self.assertIn('data-testsuite=""', html) + # Should include the list of available testsuites + self.assertIn('data-testsuites=', html) + + def test_admin_route_trailing_slash(self): + """/v5/admin/ (trailing slash) must hit the admin route, not the catch-all.""" + resp = self.client.get('/v5/admin/') + self.assertEqual(resp.status_code, 200) + html = resp.get_data(as_text=True) + self.assertIn('id="v5-app"', html) + self.assertIn('data-testsuite=""', html) + + def test_deeply_nested_route(self): + """Catch-all should handle deep paths.""" + resp = self.client.get('/v5/nts/regressions/some-uuid') + self.assertEqual(resp.status_code, 200) + html = resp.get_data(as_text=True) + self.assertIn('id="v5-app"', html) + + # --- SPA template content --- + + def test_spa_template_has_testsuites_data(self): + resp = self.client.get('/v5/nts/') + html = resp.get_data(as_text=True) + self.assertIn('data-testsuites=', html) + # Should contain "nts" in the testsuites JSON + self.assertIn('nts', html) + + def test_spa_template_has_v4_url(self): + resp = self.client.get('/v5/nts/') + html = resp.get_data(as_text=True) + self.assertIn('data-v4-url=', html) + + def test_spa_template_loads_v5_assets(self): + resp = self.client.get('/v5/nts/') + html = resp.get_data(as_text=True) + self.assertIn('v5/v5.js', html) + self.assertIn('v5/v5.css', html) + self.assertIn('plotly', html) + + def test_spa_template_has_lnt_url_base(self): + resp = self.client.get('/v5/nts/') + html = resp.get_data(as_text=True) + self.assertIn('var lnt_url_base=', html) + + def test_spa_template_hides_v4_navbar(self): + """The v5 SPA uses nonav to suppress the v4 navbar.""" + resp = self.client.get('/v5/nts/') + html = resp.get_data(as_text=True) + # The v4 navbar contains "navbar-fixed-top" — should NOT be present + # when nonav is set (the     ` row with a tri-state checkbox. Unchecked when no tests selected, indeterminate when some selected, checked when all selected. Clicking it: if not all selected → select all visible tests; if all selected → deselect all. No 200ms delay (unambiguous target outside tbody). State updated via `updateHeaderCheckbox()` in `buildRows()`. + - Hover dispatches `GRAPH_TABLE_HOVER` with bare test name. + - `highlightRow(testName)` matches on `data-test` attribute (bare test names). + - `update()` rebuilds all rows via `tbody.replaceChildren()`. + +4. **`renderFromSelection` — the main render function**: + - Builds `TestSelectionEntry[]` from `allMatchingTests`. Colors assigned by test index in `allMatchingTests` (stable across selection changes). + - Updates the test selection table (`tableHandle.update(entries, message)`). + - Message: `"3 of 1200 tests selected"` or `"3 of 1200 tests selected, loading..."`. + - Builds chart traces only from `selectedTests` using `buildTraces()` per machine per test. `buildTraces` applies two-step aggregation: first `sampleAgg` within each run (grouping by `run_uuid`), then `runAgg` across runs. This matches the Compare page's `aggregateSamplesWithinRun` + `aggregateAcrossRuns` pipeline. + - Deferred chart update via `requestAnimationFrame` with generation counter. + +5. **`renderChartOnly` — progressive chart update without table rebuild**: + - Called from `onProgress` during data fetch. Reads cached data for selected tests, builds traces, updates chart. Does NOT touch the table (avoids rebuilding many rows per progress tick). + +6. **Hover sync** (wired in `mount()`): + - **Table→Chart**: `GRAPH_TABLE_HOVER` carries a bare test name. Listener maps to `traceName(testName, machines[0])` and calls `chartHandle.hoverTrace()`. For multi-machine, highlights the first machine's trace only (acceptable limitation without modifying time-series-chart.ts). + - **Chart→Table**: `GRAPH_CHART_HOVER` carries a trace name (`testName · machine`). Listener extracts test name via `testNameFromTrace(tn)` and calls `tableHandle.highlightRow(testName)`. + +7. **`GraphDataCache` — centralized data access layer** (unchanged class): + - Same `GraphDataCache` class in `pages/graph-data-cache.ts`. All methods unchanged. + - `filterTestNames` standalone function is **deleted** — no longer needed. The graph page inlines the text filter logic (simple `.filter()` call). + - Cache persists across navigation. `cache.clear()` called on suite change. + +8. **Baselines — asynchronous fetch with aggregation**: + - Baseline data is fetched only for **selected** tests (not all discovered tests). + - `addCurrentBaseline` uses `[...selectedTests]` when calling `cache.getBaselineData()`. + - Aggregation consistency: same as before (runAgg applied per test). + +9. **Module-level state**: + - `allMatchingTests: string[]` — all test names matching the current filter (no cap). **Preserved across unmount/remount**. + - `selectedTests: Set` — user's explicit selection. **Preserved across unmount/remount** (like `cache`), so back-nav restores previous chart. + - `loadingTests: Set` — tests with in-flight data fetches. Reset on unmount. + - `tableHandle: TestSelectionTableHandle | null` — destroyed on unmount, recreated on mount. + - `selectionAbort: AbortController | null` — aborted on each new `handleSelectionChange` and on unmount. + - Removed: `discoveredTests`, `discoveredTruncated`, `manuallyHidden`, `currentVisibleTraceNames`, `legendHandle`, `MAX_DISPLAYED_TESTS`, `computeActiveTests`. + +10. **URL state**: + - `?suite={name}&machine={name}&machine={name2}&metric={name}&test_filter={text}&run_agg={fn}&sample_agg={fn}&baseline={suite}::{machine}::{order}` + - Selected tests are **NOT** in the URL (names can be very long). They are ephemeral page state preserved via module-scope variables across SPA navigation. + - `updateUrlState()` called from all interactive handlers. ### 3.4 Phase 3 Testing **Tests for `time-series-chart.ts`** (`__tests__/time-series-chart.test.ts`): -- `createTimeSeriesChart` returns a valid `ChartHandle` -- `ChartHandle.update()` calls `Plotly.react()` (not `newPlot`) for incremental updates -- Data preparation: verify traces are built correctly from input data -- Baselines: verify baseline traces (not shapes) are generated with correct y-values, dash style, `showlegend: false`, and hover template containing baseline order value, tag, test name, and metric value; verify each baseline trace's color matches the corresponding main trace's color; verify scaffold x-range is used when `categoryOrder` is provided; verify no baseline traces are generated for tests not in the main traces -- X-axis scaffolding: verify that when `categoryOrder` is provided, the layout sets `xaxis.categoryarray` and `xaxis.categoryorder = 'array'`; verify that when `categoryOrder` is omitted, these layout properties are not set -- Marker symbols: verify that `markerSymbol` on `TimeSeriesTrace` is passed through to Plotly's `marker.symbol` -- Trace naming: verify that the Plotly trace name is `{testName} - {machine}` -- Empty chart annotation: verify that when traces are empty and `categoryOrder` is set, a Plotly annotation is added at paper coordinates (0.5, 0.5) with "No data to plot" -- `plotReady` promise: verify that `update()` chains `Plotly.react()` after the `plotReady` promise from `newPlot()`, preventing race conditions -- `ChartHandle.destroy()` calls `Plotly.purge()` -- Trace highlighting via `hoverTrace()`: verify that `hoverTrace(testName)` calls `Plotly.restyle()` to set the hovered trace to opacity 1.0 and line width 3, while dimming all other traces to opacity 0.2; verify that `hoverTrace(null)` restores all traces to opacity 1.0 and line width 1.5; verify that baseline traces are dimmed along with non-hovered main traces; verify restyle calls are chained after `plotReady` -- Raw value scatter: verify that when `getRawValues` returns >1 values, `Plotly.addTraces()` is called with a markers-only scatter trace at the hovered x-position; verify the scatter trace uses the same color at opacity 0.3; verify `Plotly.deleteTraces()` is called on unhover; verify no scatter trace is added when `getRawValues` returns ≤1 values; verify no scatter trace is added when `getRawValues` is not provided -- Zoom preservation: verify that `update()` passes the current `xaxis.range` and `xaxis.autorange` from `chartDiv.layout` to `Plotly.react()`, so x-axis zoom is preserved; verify that when `yaxis.autorange` is `false` on the chart div, the y-axis range is also preserved; verify that when `yaxis.autorange` is `true`, no explicit y-axis range is set (allowing auto-range); verify that after a zoom reset (both axes `autorange` set back to `true`), the next `update()` does not set explicit ranges - -**Tests for `fetchOneCursorPage`** (`__tests__/api.test.ts`): -- Returns data points and next cursor from a paginated response -- Returns `nextCursor: null` on the last page -- Passes abort signal through to fetch +- Unchanged — all existing tests remain valid. + +**Tests for `test-selection-table.ts`** (`__tests__/components/test-selection-table.test.ts`): +- Renders all entries as rows with checkboxes; selected rows have checked checkboxes and colored symbol; unselected rows have unchecked checkboxes +- Single click toggles selection, calls `onSelectionChange` after 200ms delay +- Shift-click selects range immediately (no 200ms delay), calls `onSelectionChange` with batch +- Shift-click with stale `lastClickedIndex` (test name no longer in entries) — treated as normal click +- Double-click isolates (select only this test) or restores all (if already the sole selection) +- Loading entries show loading indicator +- Hover dispatches `GRAPH_TABLE_HOVER` with bare test name +- `highlightRow` adds/removes `.row-highlighted` class matching on `data-test` (bare test name) +- `update()` replaces content +- `destroy()` cleans up **Tests for `pages/graph.ts`** (`__tests__/pages/graph.test.ts`): -- Suite selector: verify ` showing "-- Select metric --" on Graph and Compare pages, eliminating visual flicker during metric loading. Co-Authored-By: Claude Opus 4.6 (1M context) --- .../v5/frontend/src/__tests__/pages/graph.test.ts | 14 +++++++++----- .../v5/frontend/src/components/metric-selector.ts | 13 +++++++++++++ lnt/server/ui/v5/frontend/src/pages/graph.ts | 7 ++++--- lnt/server/ui/v5/frontend/src/selection.ts | 4 ++-- 4 files changed, 28 insertions(+), 10 deletions(-) diff --git a/lnt/server/ui/v5/frontend/src/__tests__/pages/graph.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/pages/graph.test.ts index 4c7a465a4..ec027f03a 100644 --- a/lnt/server/ui/v5/frontend/src/__tests__/pages/graph.test.ts +++ b/lnt/server/ui/v5/frontend/src/__tests__/pages/graph.test.ts @@ -552,15 +552,19 @@ describe('graphPage mount', () => { expect(getFields).toHaveBeenCalledWith('nts'); }); - it('shows metric loading message then selector after getFields resolves', async () => { + it('shows disabled metric selector then enabled selector after getFields resolves', async () => { graphPage.mount(container, { testsuite: 'nts' }); - // Loading state should exist synchronously - expect(container.querySelector('.progress-label')?.textContent).toBe('Loading metrics...'); + // Loading state: disabled metric selector with placeholder + const loading = container.querySelector('.metric-select') as HTMLSelectElement; + expect(loading).toBeTruthy(); + expect(loading.disabled).toBe(true); - // After fields load, metric selector should appear + // After fields load, metric selector should be enabled await vi.waitFor(() => { - expect(container.querySelector('.metric-select')).toBeTruthy(); + const select = container.querySelector('.metric-select') as HTMLSelectElement; + expect(select).toBeTruthy(); + expect(select.disabled).toBe(false); }); }); diff --git a/lnt/server/ui/v5/frontend/src/components/metric-selector.ts b/lnt/server/ui/v5/frontend/src/components/metric-selector.ts index 622e2337f..a9c94d163 100644 --- a/lnt/server/ui/v5/frontend/src/components/metric-selector.ts +++ b/lnt/server/ui/v5/frontend/src/components/metric-selector.ts @@ -19,6 +19,19 @@ export interface MetricSelectorOptions { * If initialValue matches a field name, that option is pre-selected. * Returns the effective initial metric name ('' when placeholder is active). */ +/** + * Render a disabled metric dropdown with a placeholder option. + * Used when no suite is selected yet and metrics aren't available. + */ +export function renderEmptyMetricSelector(container: HTMLElement): void { + const group = el('div', { class: 'control-group' }); + group.append(el('label', {}, 'Metric')); + const select = el('select', { class: 'metric-select', disabled: '' }) as HTMLSelectElement; + select.append(el('option', { value: '' }, '-- Select metric --')); + group.append(select); + container.append(group); +} + export function renderMetricSelector( container: HTMLElement, fields: FieldInfo[], diff --git a/lnt/server/ui/v5/frontend/src/pages/graph.ts b/lnt/server/ui/v5/frontend/src/pages/graph.ts index df45b199f..ddedff2fb 100644 --- a/lnt/server/ui/v5/frontend/src/pages/graph.ts +++ b/lnt/server/ui/v5/frontend/src/pages/graph.ts @@ -7,7 +7,7 @@ import { el, debounce, getAggFn, primaryOrderValue, TRACE_SEP, machineColor } fr import { getTestsuites } from '../router'; import { onCustomEvent, GRAPH_TABLE_HOVER, GRAPH_CHART_HOVER } from '../events'; import { renderMachineCombobox } from '../components/machine-combobox'; -import { renderMetricSelector, filterMetricFields } from '../components/metric-selector'; +import { renderMetricSelector, renderEmptyMetricSelector, filterMetricFields } from '../components/metric-selector'; import { createOrderPicker, fetchMachineOrderSet } from '../combobox'; import { type TimeSeriesTrace, type PinnedBaseline, type ChartHandle, @@ -161,7 +161,7 @@ export const graphPage: PageModule = { // Metric selector (loaded async — actual fetch deferred until suite is set) const metricGroup = el('div', {}); - metricGroup.append(el('span', { class: 'progress-label' }, 'Select a suite to load metrics...')); + renderEmptyMetricSelector(metricGroup); // Test filter const filterGroup = el('div', { class: 'control-group' }); @@ -843,7 +843,8 @@ export const graphPage: PageModule = { // Fetch initial fields for the selected suite function loadFieldsForSuite(suite: string): void { const myGen = suiteGeneration; - metricGroup.replaceChildren(el('span', { class: 'progress-label' }, 'Loading metrics...')); + metricGroup.replaceChildren(); + renderEmptyMetricSelector(metricGroup); getFields(suite).then(fields => { if (myGen !== suiteGeneration) return; metricGroup.replaceChildren(); diff --git a/lnt/server/ui/v5/frontend/src/selection.ts b/lnt/server/ui/v5/frontend/src/selection.ts index 21f0f5188..8c21f421d 100644 --- a/lnt/server/ui/v5/frontend/src/selection.ts +++ b/lnt/server/ui/v5/frontend/src/selection.ts @@ -8,7 +8,7 @@ import { createOrderCombobox, createMachineCombobox, resetComboboxState, type ComboboxContext, } from './combobox'; -import { renderMetricSelector, filterMetricFields } from './components/metric-selector'; +import { renderMetricSelector, renderEmptyMetricSelector, filterMetricFields } from './components/metric-selector'; // Per-side cached data let cachedOrdersA: OrderSummary[] = []; @@ -289,7 +289,7 @@ export function renderSelectionPanel(root: HTMLElement): void { tryAutoCompare(); }, getState().metric, { placeholder: true }); } else { - metricContainer.append(el('span', { class: 'progress-label' }, 'Select a suite to load metrics...')); + renderEmptyMetricSelector(metricContainer); } globalRow.append(metricContainer); From 67f683c039cd6b87087af138d31ec4805e87a496 Mon Sep 17 00:00:00 2001 From: Louis Dionne Date: Mon, 13 Apr 2026 12:08:52 -0400 Subject: [PATCH 035/143] [UI] Extract DOUBLE_CLICK_DELAY_MS constant to utils Replace magic 200ms literal in test-selection-table with a named constant so the value is discoverable and stays in sync if it needs tuning. Co-Authored-By: Claude Opus 4.6 (1M context) --- .../ui/v5/frontend/src/components/test-selection-table.ts | 4 ++-- lnt/server/ui/v5/frontend/src/utils.ts | 3 +++ 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/lnt/server/ui/v5/frontend/src/components/test-selection-table.ts b/lnt/server/ui/v5/frontend/src/components/test-selection-table.ts index 78cc0fa94..c67345856 100644 --- a/lnt/server/ui/v5/frontend/src/components/test-selection-table.ts +++ b/lnt/server/ui/v5/frontend/src/components/test-selection-table.ts @@ -1,7 +1,7 @@ // components/test-selection-table.ts — Test selection table for the graph page. // Shows all matching tests with checkboxes for explicit plot selection. -import { el } from '../utils'; +import { el, DOUBLE_CLICK_DELAY_MS } from '../utils'; import { GRAPH_TABLE_HOVER } from '../events'; export interface TestSelectionEntry { @@ -195,7 +195,7 @@ export function createTestSelectionTable( const sel = currentSelection(); if (sel.has(testName)) { sel.delete(testName); } else { sel.add(testName); } currentOnSelectionChange(sel); - }, 200); + }, DOUBLE_CLICK_DELAY_MS); }); tbody.addEventListener('dblclick', (e) => { diff --git a/lnt/server/ui/v5/frontend/src/utils.ts b/lnt/server/ui/v5/frontend/src/utils.ts index cd46a97b8..e5ae57867 100644 --- a/lnt/server/ui/v5/frontend/src/utils.ts +++ b/lnt/server/ui/v5/frontend/src/utils.ts @@ -7,6 +7,9 @@ import { navigate, getBasePath, getUrlBase } from './router'; */ export const TRACE_SEP = ' \u00b7 '; +/** Delay (ms) to distinguish single-click from double-click. */ +export const DOUBLE_CLICK_DELAY_MS = 200; + // Aggregation functions /** Default Plotly color palette, shared across Graph and Dashboard sparklines. */ From 2809893f7e84a310176b8a563ef456e854c85c27 Mon Sep 17 00:00:00 2001 From: Louis Dionne Date: Mon, 13 Apr 2026 18:18:25 -0400 Subject: [PATCH 036/143] [DB] Add v5 database layer with Commit model MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Port the v5 DB layer, design documents, and supporting infrastructure from the v5-with-new-db-layer branch. This is the first step toward incrementally converging the two branches. New: lnt/server/db/v5/ (V5DB, V5TestSuiteDB, dynamic models, schema parser, query_trends for geomean aggregation), design docs (v5-db.md, orders discussion, regression workflow), DB implementation plan, and tests. Modified: config.py accepts db_version '5.0', app.py conditionally registers v4/v5 routes, lnt create gains --db-version flag, test helper supports v5 instances. import_run() supports both scalar and array metric values — arrays create multiple Sample rows per test entry. Co-Authored-By: Claude Opus 4.6 (1M context) --- docs/design/v5-db.md | 400 ++++++ docs/design/v5-discussion-about-orders.md | 260 ++++ docs/design/v5-regression-workflow-changes.md | 160 +++ docs/v5-db-implementation-plan.md | 710 ++++++++++ docs/v5-submission-guide.md | 199 +++ lnt/lnttool/create.py | 15 +- lnt/server/config.py | 15 +- lnt/server/db/v5/__init__.py | 1255 +++++++++++++++++ lnt/server/db/v5/models.py | 402 ++++++ lnt/server/db/v5/schema.py | 230 +++ lnt/server/ui/app.py | 35 +- tests/server/db/v5/__init__.py | 0 tests/server/db/v5/test_crud.py | 648 +++++++++ tests/server/db/v5/test_import.py | 734 ++++++++++ tests/server/db/v5/test_models.py | 626 ++++++++ tests/server/db/v5/test_schema.py | 328 +++++ tests/server/db/v5/test_time_series.py | 333 +++++ tests/utils/with_temporary_instance.py | 106 +- 18 files changed, 6427 insertions(+), 29 deletions(-) create mode 100644 docs/design/v5-db.md create mode 100644 docs/design/v5-discussion-about-orders.md create mode 100644 docs/design/v5-regression-workflow-changes.md create mode 100644 docs/v5-db-implementation-plan.md create mode 100644 docs/v5-submission-guide.md create mode 100644 lnt/server/db/v5/__init__.py create mode 100644 lnt/server/db/v5/models.py create mode 100644 lnt/server/db/v5/schema.py create mode 100644 tests/server/db/v5/__init__.py create mode 100644 tests/server/db/v5/test_crud.py create mode 100644 tests/server/db/v5/test_import.py create mode 100644 tests/server/db/v5/test_models.py create mode 100644 tests/server/db/v5/test_schema.py create mode 100644 tests/server/db/v5/test_time_series.py diff --git a/docs/design/v5-db.md b/docs/design/v5-db.md new file mode 100644 index 000000000..359c4b038 --- /dev/null +++ b/docs/design/v5-db.md @@ -0,0 +1,400 @@ +# v5 Database Layer Design + +This document captures the design constraints and decisions for the v5 database +layer. It is the authoritative reference for what the v5 DB does and why. + +For the exploration and discussion that led to these decisions, see +`v5-discussion-about-orders.md` in this directory. + + +## D1: Architecture and Separation + +- The v5 DB layer lives in `lnt/server/db/v5/`, a self-contained package with + its own schema parsing, models, and CRUD interface. +- No imports from v4 DB code (`lnt.server.db.testsuite`, `testsuitedb`, + `v4db`, `fieldchange`, `regression`). The v5 package is fully independent. +- v4 and v5 coexist in the same codebase, selected by `db_version` in the LNT + config file (`'0.4'` for v4, `'5.0'` for v5). +- A v5 instance serves only v5 API endpoints. A v4 instance serves v4 views + and the v4 REST API only. The v5 REST API and v5 frontend are available + only on v5 instances. +- Postgres only. No SQLite or MySQL support. +- SQLAlchemy 1.3 (same version as v4, to avoid upgrade risk). +- All new code uses Python 3.10+ idioms: type hints (`X | Y`, `list[T]`), + dataclasses, f-strings, `match` where appropriate. + + +## D2: The Commit Concept (replaces Orders) + +The v4 "Order" concept conflated three concerns: identity (what groups runs), +ordering (sequential position for time-series), and display (what the UI shows). +The v5 "Commit" concept cleanly separates these. + +- **Commit**: A named point that groups runs. The `commit` column is a single + string (e.g., a Git SHA, version number, or ad-hoc label like + `"experiment-vectorizer-v2"`). It is the identity of the commit. By default, + the UI also uses it for display, but a `commit_field` marked `display: true` + overrides what is shown (see D4). Every run must have a commit. +- **Ordinal**: An optional integer that places the commit in a total order. + Always assigned via PATCH, never inferred from the commit string (even if the + string is numeric). `NULL` means unordered. + +Two tiers of runs: +1. Run with ordered commit (ordinal set): full time-series participation. +2. Run with unordered commit (ordinal NULL): grouped but not positioned in the + time series. Used for throwaway A/B comparisons (use an ad-hoc commit + string like `"experiment-vectorizer-v2"`), or as the transient state before + an external process assigns an ordinal. + +Cleanup: unordered commits that are no longer needed can be deleted via the API, +which cascades to their runs and samples. + + +## D3: Schema Storage and Lifecycle + +Test suite schemas are created via the API (`POST /api/v5/test-suites`) and +persisted in the database, not on the filesystem. The `schemas/*.yaml` files +in the repository are documentation/examples only -- the server does not read +them. + +**Global tables** (not per-suite, shared across all suites): + +| Table | Columns | +|---|---| +| `v5_schema` | `name` (String PK), `schema_json` (Text), `created_at` (DateTime) | +| `v5_schema_version` | `id` (Integer PK, always 1), `version` (Integer) | + +On startup, `V5DB` reads all rows from `v5_schema`, parses each into a +`TestSuiteSchema`, and builds in-memory models. The `v5_schema_version` counter +is cached. + +**Multi-process safety**: In a multi-worker deployment (e.g., gunicorn), when +one worker creates or deletes a suite, it bumps the `v5_schema_version` counter +in the same transaction. Other workers detect the stale cache on their next +request and reload schemas from the DB. The check is a single-row query per +request. Callers access suites via `V5DB.get_suite(name)`, which handles the +staleness check transparently. + + +## D4: Schema Format + +Each test suite is defined by a YAML schema file. The v5 format is a clean +break from v4 (no backward compatibility required). + +```yaml +name: nts + +metrics: +- name: compile_time + type: real # real | status | hash + display_name: Compile Time + unit: seconds + unit_abbrev: s + bigger_is_better: false +- name: execution_time + type: real +- name: compile_status + type: status + +machine_fields: +- name: hardware + searchable: true +- name: os + searchable: true + +commit_fields: +- name: git_sha + searchable: true +- name: author + searchable: true +- name: commit_message + type: text # default (String 256) | text | integer | datetime +- name: commit_timestamp + type: datetime +``` + +Key differences from v4: +- `run_fields` with `order: true` is gone. The commit is a built-in concept. +- `run_fields` section is removed entirely — extra run data goes in + `run_parameters` (JSONB). +- `commit_fields` defines optional typed metadata columns on the Commit table. +- `searchable: true` on commit_fields or machine_fields enables `?search=` + prefix matching on the corresponding list API endpoint. +- `display: true` on at most one commit_field is a hint for the UI: when set + and the field has a non-null value, the UI shows that value instead of the + raw commit string (e.g., a shortened SHA, a version tag). This is purely a + UI concern -- the DB layer does not treat display fields specially. +- No `format_version` in the schema file (only one format exists for v5). + + +## D5: Data Model + +Per-suite tables are dynamically named (e.g., `nts_Commit`, `nts_Run`). + +### `{suite}_Commit` + +| Column | Type | Constraints | +|--------|------|-------------| +| id | Integer | PK | +| commit | String(256) | unique, not null | +| ordinal | Integer | nullable, unique | +| _(dynamic)_ | per commit_fields | nullable | + +- `commit` is the identity string provided by submitters. Used as the default + display value in the UI unless a `commit_field` with `display: true` is + defined and populated. +- `ordinal` has a regular unique constraint. Ordinals are assigned once by an + external process and are not expected to be reassigned. +- Dynamic columns are created from `commit_fields` in the schema. +- No linked list (NextOrder/PreviousOrder from v4 are gone). +- No `label` built-in column. If labeling is needed, define a `label` field + in `commit_fields`. +- Commits are deletable. Deleting a commit cascades to its runs (and their + samples). FieldChanges referencing a deleted commit must be deleted first + (the API enforces this). +- Schema-defined `commit_fields` names must not collide with built-in column + names (`id`, `commit`, `ordinal`). The schema parser rejects these. + +### `{suite}_Machine` + +| Column | Type | Constraints | +|--------|------|-------------| +| id | Integer | PK | +| name | String(256) | unique, not null | +| parameters | JSONB | not null, default `{}` | +| _(dynamic)_ | per machine_fields | nullable | + +- `name` uniqueness is enforced (fixes a v4 bug). +- `parameters` stores extra key-value data as Postgres JSONB. +- Schema-defined `machine_fields` names must not collide with built-in column + names (`id`, `name`, `parameters`). The schema parser rejects these. + +### `{suite}_Run` + +| Column | Type | Constraints | +|--------|------|-------------| +| id | Integer | PK | +| uuid | String(36) | unique, not null, indexed | +| machine_id | Integer FK → Machine | not null, indexed | +| commit_id | Integer FK → Commit | not null, indexed | +| submitted_at | DateTime | not null | +| run_parameters | JSONB | not null, default `{}` | + +- Every run must have a commit (`commit_id` is not null). +- `submitted_at` replaces v4's `start_time`/`end_time` (client-side timing + goes in `run_parameters` if needed). +- Cascade: deleting a machine cascades to its runs; deleting a commit cascades + to its runs. Deleting a run cascades to its samples. + +### `{suite}_Test` + +| Column | Type | Constraints | +|--------|------|-------------| +| id | Integer | PK | +| name | String(256) | unique, not null | + +### `{suite}_Sample` + +| Column | Type | Constraints | +|--------|------|-------------| +| id | Integer | PK | +| run_id | Integer FK → Run | not null | +| test_id | Integer FK → Test | not null | +| _(dynamic)_ | per metrics | nullable | + +- Compound index on `(run_id, test_id)`. +- Dynamic columns from schema metrics: `real` → Float, `status` → Integer, + `hash` → String(256). + +### `{suite}_FieldChange` + +| Column | Type | Constraints | +|--------|------|-------------| +| id | Integer | PK | +| uuid | String(36) | unique, not null, indexed | +| test_id | Integer FK → Test | not null | +| machine_id | Integer FK → Machine | not null | +| field_name | String(256) | not null | +| start_commit_id | Integer FK → Commit | not null | +| end_commit_id | Integer FK → Commit | not null | +| old_value | Float | nullable | +| new_value | Float | nullable | + +- `field_name` is a plain string (metric name), not a FK to a metatable. + Simpler for an API-driven system. +- Compound index on `(machine_id, test_id, field_name)`. + +### `{suite}_Regression` + +| Column | Type | Constraints | +|--------|------|-------------| +| id | Integer | PK | +| uuid | String(36) | unique, not null, indexed | +| title | String(256) | nullable | +| bug | String(256) | nullable | +| state | Integer | not null, indexed | + +Regression state values: + +| Value | Name | +|-------|------------------| +| 0 | detected | +| 1 | staged | +| 2 | active | +| 3 | not_to_be_fixed | +| 4 | ignored | +| 5 | fixed | +| 6 | detected_fixed | + +The DB layer validates state values on create and update. + +### `{suite}_RegressionIndicator` + +| Column | Type | Constraints | +|--------|------|-------------| +| id | Integer | PK | +| regression_id | Integer FK → Regression | not null, indexed | +| field_change_id | Integer FK → FieldChange | not null | + +- Unique constraint on `(regression_id, field_change_id)`. +- Many-to-many join table between Regression and FieldChange. + +### Tables dropped from v4 + +- **Baseline**: v5 comparisons are stateless API operations. +- **ChangeIgnore**: There is no "ignore" state on FieldChanges. If a field + change is not relevant, it should not be created. The external process that + creates field changes is responsible for filtering. +- **Profile**: Profiling is a separate concern. +- **Order**: Replaced by Commit. + + +## D6: Submission Format + +Runs are submitted as JSON via `POST /api/v5/{suite}/runs`. + +```json +{ + "format_version": "5", + "machine": { + "name": "my-machine", + "hardware": "x86_64", + "os": "linux" + }, + "commit": "abc123def456", + "commit_fields": { + "git_sha": "abc123def456789...", + "author": "Jane Doe", + "commit_message": "Fix vectorizer regression" + }, + "run_parameters": { + "build_config": "Release" + }, + "tests": [ + { + "name": "test.suite/benchmark", + "execution_time": 1.23, + "compile_time": 0.45 + } + ] +} +``` + +- `format_version`: Required, must be `"5"`. +- `machine`: Required. `name` is required; other keys match `machine_fields` + from the schema and are stored in the corresponding columns. Keys that do not + match any `machine_fields` entry go into the `parameters` JSONB blob. +- `commit`: Required string. Identifies which commit this run belongs to. +- `commit_fields`: Optional. Keys match `commit_fields` from the schema. + First-write-wins: if the commit already exists, metadata is not overwritten. + Use PATCH on the commit to update metadata after creation. +- `run_parameters`: Optional. Stored as JSONB on the Run. +- `tests`: Required. Each entry has `name` plus metric values. Metric values + may be scalars or arrays. An array value (e.g. `"execution_time": [0.1, 0.2]`) + creates one Sample row per element. All arrays in a single test entry must + have the same length; scalar values are repeated across the resulting rows. + + +## D7: Commit Metadata Population + +Commit metadata (`commit_fields`) can be set via two paths: + +1. **Inline during run submission**: The `commit_fields` dict in the submission + JSON populates metadata on the Commit record when it is first created. + If the commit already exists, metadata is NOT overwritten (first-write-wins). +2. **Via PATCH**: `PATCH /api/v5/{suite}/commits/{value}` can set or update + metadata fields at any time, overwriting existing values. + +Ordinals are set exclusively via PATCH (see D11). + + +## D8: No Regression Auto-Detection + +All FieldChanges and Regressions are created, updated, and deleted via the API. +There is no `regenerate_fieldchanges_for_run()` or +`identify_related_changes()`. The v5 DB layer provides CRUD only. + +Regression detection is the responsibility of an external process (a separate +tool or CI job) that analyzes time-series data and creates FieldChanges via the +API when it detects significant changes. + + +## D9: Search + +List endpoints for commits and machines support a unified `?search=` parameter. + +- `GET /commits?search=abc` matches `commit` column OR any `searchable` + commit_field via case-insensitive prefix matching (OR semantics). +- `GET /machines?search=x86` matches `name` column OR any `searchable` + machine_field. +- This replaces v4's ad-hoc `tag_prefix`, `name_prefix`, `name_contains` + parameters with a consistent pattern. + + +## D10: Time-Series Queries + +The primary query pattern is: "give me metric values for (machine, test, +metric) ordered by commit ordinal." + +This is `Sample JOIN Run JOIN Commit` filtered by `machine_id` and `test_id`, +ordered by `Commit.ordinal`. + +When sorting by ordinal, commits without ordinals are excluded (they have no +meaningful position). When not sorting by ordinal, all runs are included +regardless of their commit's ordinal. + +Cursor-based pagination (encoding, decoding, tiebreakers) is an API-layer +concern. The DB layer provides filtering, sorting, and limit parameters only. + + +## D11: Ordinal Management + +- Ordinals are always `NULL` on commit creation. +- Ordinals are assigned exclusively via `PATCH /commits/{value}`. +- Even numeric commit strings (e.g., `"311066"`) do not auto-assign ordinals. +- The unique constraint on ordinal is a regular (non-deferred) constraint. + Ordinals are assigned once by an external process and are not expected to + be reassigned. +- `previous` and `next` navigation on a commit is computed by querying for + the nearest lower/higher ordinal (not a linked list). + + +## D12: Migration from v4 + +A separate offline tool (`lnt admin migrate-to-v5`) converts a v4 database to +a v5 Postgres database: + +- Orders → Commits: primary order field value becomes the commit string, + linked-list position becomes the ordinal. +- v4 `tag` column on Order → a `label` commit_field (if defined in the schema). +- Run.order_id → Run.commit_id; Run.start_time → Run.submitted_at. +- FieldChange.field_id FK → FieldChange.field_name string (resolved from + the SampleField metatable). +- Baseline, ChangeIgnore, Profile tables are not migrated. + + +## D13: Profiles (Deferred) + +Profile support is not part of the initial v5 database layer. The v4 Profile +table is dropped and no replacement is provided. Profile support will be +designed and added in a future iteration. diff --git a/docs/design/v5-discussion-about-orders.md b/docs/design/v5-discussion-about-orders.md new file mode 100644 index 000000000..bc1a05893 --- /dev/null +++ b/docs/design/v5-discussion-about-orders.md @@ -0,0 +1,260 @@ +# Design Discussion: Rethinking Orders and Identifiers + +This document captures the design discussion about decoupling run identity from +ordering in LNT, and introducing richer commit metadata on orders. + +## Problem Statement + +Most LNT test suites define orders as a git distance (an integer). While +functionally correct for sorting, this is not very helpful when trying to make +sense of what an order actually represents. We want to: + +1. Store meaningful commit information (Git SHA, author, message) alongside + orders. +2. Support one-off A/B comparisons without cluttering the order space. +3. Cleanly separate the concepts of "identity" (what groups runs together) + from "ordering" (sequential position for time-series analysis). + +## Current Architecture + +### Order Table + +Each test suite has a per-suite Order table with: +- `ID` (Integer PK) +- `NextOrder` / `PreviousOrder` (Integer FKs forming a linked list) -- in + production +- `ordinal` (Integer) -- introduced on the v5 branch but not yet in production +- Dynamic `String(256)` columns for each order field (e.g., + `llvm_project_revision`) + +### Schema Definition + +Orders are defined by marking a run field with `order: true` in the YAML +schema: + +```yaml +run_fields: +- name: llvm_project_revision + order: true +``` + +There is no type control (always `String(256)`), no metadata concept, and no +way to separate the sort key from the display label. + +### Ordering Mechanism + +`_getOrCreateOrder()` determines an order's position at insertion time by +comparing field values via `convert_revision()`, which parses strings into +numeric tuples. Non-numeric strings (like Git SHAs) get hashed, producing +essentially random ordering. The order field value serves a dual purpose: it is +both the identity (used for lookups and display) and the sort key. + +### Dual-Purpose Problem + +This conflation means: +- You can't store a monotonic sort key (git distance) while displaying a + human-meaningful identifier (SHA). +- Every run must have an order, even throwaway A/B comparisons. +- The system must understand the format of the order value to sort it + (`convert_revision()`). + +## Exploration of Approaches + +### Approach A: Add a `parameters_data` Blob to Order + +Like Machine and Run already have. An external process or PATCH call populates +it with arbitrary JSON (SHA, author, message). Submitters stay unchanged. + +**Verdict**: Simple but doesn't address the display concern or the A/B +comparison problem. + +### Approach B: New `order_fields` Section in the Schema + +A dedicated `order_fields` section defines additional typed columns on the Order +table: + +```yaml +run_fields: +- name: llvm_project_revision + order: true # sort key (unchanged) + +order_fields: # NEW +- name: git_sha + display: true # UI shows this instead of sort key +- name: commit_message + type: text # Text column for large strings +``` + +Order metadata fields are populated via PATCH only, not by run submissions. One +field can be marked `display: true` for the UI. + +**Verdict**: Addresses display and metadata, but doesn't address A/B +comparisons or the fundamental coupling between identity and ordering. + +### Approach C: Runs Submit SHA, External Process Assigns Ordinal + +Flip the model: submitters send what's natural (a Git SHA) as the order field. +The Order is created with no position (`ordinal = NULL`). An external process +later assigns the ordinal. + +**Verdict**: Clean separation, but doesn't address metadata or the A/B +comparison problem on its own. + +### Key Insight: `ordinal` Hasn't Shipped + +The `ordinal` column is a v5 branch addition, not in production. This means we +can design it from scratch to be nullable, natively supporting Approach C +without backward-compatibility constraints. + +### Combined Approach: B + C + +Approaches B and C complement each other: +- **C handles identity + positioning**: What identifies an order (SHA), and how + its position is determined (nullable ordinal, externally assigned). +- **B handles metadata + display**: What additional info lives on the order + (commit message, author), and what the UI shows. + +For new test suites (SHA-based): the order field IS the display value (the +SHA), ordinal is just for sorting. `display: true` isn't needed. + +For existing test suites (git-distance-based): `display: true` on an order +metadata field (like `git_sha`) overrides the numeric sort key in the UI. + +### The A/B Comparison Problem + +A frequently cited use case for LNT is one-off A/B comparisons with +experimental changes. Currently, every run must have a valid order, forcing +users to create dummy orders that clutter the order space. + +This led to the idea of making `order_id` on Run **nullable**: a run without +an order is a standalone data point that exists, has samples, belongs to a +machine, but isn't tied to any position in the project's history. + +This gives three tiers: +1. **Run with ordered identifier** (ordinal set): normal time-series data. +2. **Run with unordered identifier** (ordinal NULL): tied to a commit but not + yet positioned. +3. **Run with no identifier**: standalone/throwaway, for A/B comparisons. + +## Final Design Direction + +### The Core Concept: Identifiers Replace Orders + +Decouple "grouping" from "ordering" entirely: + +1. **Every run has an optional identifier** (a single string). Runs with the + same identifier are grouped together. The identifier has no inherent + ordering semantics. It could be a SHA, a label like + `"wip-experimental-vectorizer"`, or anything else. + +2. **Ordering is optional and external.** Via the API, you can assign an + ordinal to an identifier, which places it in a total order. This unlocks + time-series views, regression detection, etc. + +### Impact on v4 + +The v4 API and views can stay **completely unchanged**: +- v4 submissions always create orders (backward compatible). +- v4 queries use inner joins on Order, naturally excluding identifier-less + runs. +- Only a handful of shared DB methods need NULL guards. + +A v5 instance would only serve v5 API endpoints -- no straddling both APIs. + +### Clean Break for v5 DB Layer + +Rather than retrofitting the v4 database schema, the v5 database is a clean +redesign. Migration from v4 to v5 is handled by a separate offline tool. This +means: +- No migration constraints on the v5 schema design. +- No dual-path code in the DB layer. +- No schema format version gymnastics. +- v4 code stays frozen in the codebase for production instances. +- v5 code is clean and purpose-built. + +### Proposed v5 Data Model + +``` +Identifier: + id Integer PK + identifier String, unique, not null + ordinal Integer, nullable, unique + tag String, nullable + (metadata columns from order_fields in schema) + +Run: + id Integer PK + identifier_id Integer FK, nullable -- orderless runs just work + machine_id Integer FK + start_time DateTime + end_time DateTime + +Machine, Test, Sample -- cleaned up versions of today's tables +``` + +### Proposed Schema Format + +```yaml +name: nts + +metrics: +- name: compile_time + type: Real + ... + +run_fields: +- name: start_time +- name: end_time + +order_fields: # optional metadata on identifiers +- name: author +- name: commit_message + type: text + +machine_fields: +- name: hardware +- name: os +``` + +The identifier is a built-in concept (a single string column), not +schema-defined. `order_fields` provides optional typed metadata columns on +the Identifier table. + +### Storing Large Strings + +For metadata fields like commit messages, two options were discussed: + +- **SQLAlchemy `Text` column**: Unlimited length on SQLite/PostgreSQL. Specified + via `type: text` in the schema. +- **`Binary` column with JSON encoding**: The existing LNT pattern + (`parameters_data` on Machine/Run). Good for unstructured data. + +Schema-defined `order_fields` would use `Text` for large strings. A generic +`parameters_data` blob could also be added for unstructured metadata. + +### Population of Identifier Metadata + +Identifier metadata (commit info, ordinals) is populated **only via the API** +(e.g., `PATCH /api/v5/{ts}/identifiers/{id}`), not by run submissions. Run +submissions only provide the identifier string. An external workflow (CI hook, +cron job, etc.) handles the rest. + +### Deployment Model + +- **Production instances**: Run v4 API with v4 DB layer (unchanged). +- **Experimental instances**: Run migration tool once, then run v5 API with + v5 DB layer. +- A v5 instance serves only v5 endpoints. + +## Open Questions + +1. How should backward compatibility work for existing test suites that submit + numeric git distances? Options: auto-assign ordinal for numeric identifiers, + require external process for everyone, or make it configurable per suite. +2. Exact schema format details: does `order: true` still exist on a run field + to link submissions to identifiers, or is the identifier always a separate + top-level field in the submission JSON? +3. How does the `display: true` mechanism work in the UI -- is it needed at + all if the identifier itself (e.g., SHA) is already human-meaningful? +4. Migration tool design: how to map v4 Orders (with linked-list positions) to + v5 Identifiers (with ordinals). diff --git a/docs/design/v5-regression-workflow-changes.md b/docs/design/v5-regression-workflow-changes.md new file mode 100644 index 000000000..4cd93423f --- /dev/null +++ b/docs/design/v5-regression-workflow-changes.md @@ -0,0 +1,160 @@ +# Regression & Field Change Workflow: Discussion Summary & Plan + +## Origin + +Feature requests from a colleague using an AI agent to investigate libc++ +performance regressions on an LNT v5 instance (`lnt-feature-requests.md`). +The agent detects regressions externally, performs A/B testing, and needs to +write findings back into LNT. The v5 API's data model is too thin — only a +256-char title and a bug URL on regressions, no way to annotate field changes. + +Three original requests: +1. Add a `notes` field to Regression (free-text, for investigation findings) +2. Add a `reason` parameter to POST /field-changes/{uuid}/ignore +3. Add a `false_positive` state to the Regression state enum + +## Discussion & Design Decisions + +### Rethinking the model for external agents + +LNT is moving toward being a data store for perf data + regression tracking, +with analysis happening externally (AI agents). This changes the picture: + +- **`staged` and `detected_fixed` are dead states.** Both assumed LNT does + auto-detection. `staged` = "approved, waiting for cooldown" (cooldown from + what?). `detected_fixed` = "system noticed metric recovered." Neither has + working automation behind it. Remove from v5 API. + +- **`ignored` is redundant.** With `not_to_be_fixed` (real, won't fix) and + `false_positive` (not real), there's no remaining semantic space for + `ignored`. Remove from v5 API. + +- **FieldChanges are pure stateless data.** A FC is an observation: "metric X + changed by Y% between orders A and B on machine M." It doesn't need its own + lifecycle. The only relationship that matters is whether it's linked to a + regression (via RegressionIndicator). + +- **ChangeIgnore is not needed in v5.** It was a triage filter for + auto-detected signals ("system flagged this, but it's noise"). In the + external-agent world, the agent creates FCs deliberately — it wouldn't + create one just to ignore it. Dismissal of FCs happens at the regression + level: group them into a `false_positive` regression with notes. + +- **The ignore endpoints are removed.** POST /field-changes/{uuid}/ignore + and DELETE /field-changes/{uuid}/ignore are gone. Feature request #2 + (reason on ignore) is satisfied by regression `notes` on a `false_positive` + regression. + +### Final Regression state machine (v5 API) + +| State | DB value | Meaning | +|-------------------|----------|--------------------------------------| +| `detected` | 0 | Newly flagged, needs review | +| `active` | 10 | Confirmed real, needs investigation | +| `not_to_be_fixed` | 20 | Real regression, accepted/won't fix | +| `fixed` | 22 | Resolved | +| `false_positive` | 24 | Noise / detection error | + +Removed from v5 API (kept in DB/v4 code for backwards compat): +- `staged` (1) — unused auto-detection workflow +- `ignored` (21) — redundant with not_to_be_fixed + false_positive +- `detected_fixed` (23) — unused auto-detection workflow + +The `state_to_api()` function returns `'unknown_N'` for unmapped DB values. + +### Final FieldChange model + +FCs have no state. Properties: +- Identity: uuid +- What changed: test, machine, metric (field) +- Between when: start_order, end_order +- By how much: old_value, new_value +- Context: run (optional FK) +- Relationship: → RegressionIndicator → Regression (many-to-many) + +GET /field-changes returns ALL field changes (no exclusions), enriched with +`regression_uuids` (list of regression UUIDs the FC belongs to, empty if +unassigned). Existing filters (machine, test, metric) still work. + +### Notes on Regression + +New `notes` TEXT column. Nullable, no length limit. Accepted in POST +/regressions and PATCH /regressions/{uuid}. Returned in all GET responses +(list and detail). This is where investigation findings go — root cause +analysis, A/B test results, links to related changes, reasons for +false_positive classification, etc. + +## Implementation Plan + +### Commit 1: Database & Model Changes + +**Migration** (next upgrade script): +- Add `Notes` TEXT column to each test suite's Regression table +- Nullable, no backfill needed + +**Model** (Regression): +- Add `notes = Column("Notes", Text)` after `state` +- Update `__init__` to accept optional `notes=None` + +**State machine** (RegressionState): +- Add `FALSE_POSITIVE = 24` +- Add to `names` dict +- Do NOT remove existing constants (v4 references them) + +### Commit 2: API Changes + +**State mapping** (schemas/regressions.py STATE_TO_DB): +- Remove `'staged': 1`, `'ignored': 21`, `'detected_fixed': 23` +- Add `'false_positive': 24` + +**Regression schemas**: +- Add `notes` to create, update, list, and detail schemas + +**Regression endpoints**: +- Serialize `notes` in list and detail responses +- Accept `notes` in POST (create) and PATCH (update) + +**Field change endpoint** (GET /field-changes): +- Remove LEFT JOIN exclusion logic (ChangeIgnore + RegressionIndicator) +- Return all FCs, enriched with `regression_uuids` +- Batch query RegressionIndicator JOIN Regression after pagination + +**Remove ignore endpoints**: +- Delete POST /field-changes/{uuid}/ignore +- Delete DELETE /field-changes/{uuid}/ignore +- Remove related schemas (FieldChangeIgnoreResponseSchema) + +**Field change response shape**: +```json +{ + "uuid": "...", + "test": "...", + "machine": "...", + "metric": "...", + "old_value": 1.0, + "new_value": 2.0, + "start_order": "rev1", + "end_order": "rev2", + "run_uuid": "...", + "regression_uuids": ["uuid1", "uuid2"] +} +``` + +**Tests**: +- State mapping: false_positive round-trips; staged/ignored/detected_fixed + return unknown_N / None +- Regressions: notes CRUD (create, read list+detail, update, null); + false_positive accepted; staged/ignored/detected_fixed rejected (422) +- Field changes: list returns all FCs; regression_uuids enrichment correct; + ignore endpoints gone (404); existing filters + pagination still work + +### Commit 3: Design & Implementation Doc Updates + +- Update regression states in docs/design/v5-api.md and + docs/v5-api-implementation-plan.md +- Add notes to regression model docs +- Update field-changes section: remove ignore, list returns all with + regression_uuids +- Fix field naming inconsistency in design doc: test_name→test, + machine_name→machine, field_name→metric +- Document philosophy: FCs are stateless data, workflow at regression level diff --git a/docs/v5-db-implementation-plan.md b/docs/v5-db-implementation-plan.md new file mode 100644 index 000000000..ef2973bcc --- /dev/null +++ b/docs/v5-db-implementation-plan.md @@ -0,0 +1,710 @@ +# LNT v5 Database Layer — Implementation Plan + +This document is the step-by-step guide for implementing the v5 database layer +as specified in `docs/design/v5-db.md`. Each phase is a separate commit. + +--- + +## Phase 1: v5 Database Package — DONE + +**Commit**: `ce50c4e` on branch `v5` + +Created `lnt/server/db/v5/` with schema parsing, dynamic models, CRUD +interface, time-series queries, and schema-in-DB storage. Modified `config.py` +and `app.py` for db_version selection. + +**Files created**: +- `lnt/server/db/v5/__init__.py` — V5DB, V5TestSuiteDB +- `lnt/server/db/v5/models.py` — Dynamic model factory, global tables +- `lnt/server/db/v5/schema.py` — YAML schema parser +- `tests/server/db/v5/test_schema.py` — Schema parsing tests +- `tests/server/db/v5/test_models.py` — Model CRUD, constraint tests +- `tests/server/db/v5/test_import.py` — Import, search, suite management tests +- `tests/server/db/v5/test_time_series.py` — Time-series, field change, regression tests + +**Files modified**: +- `lnt/server/config.py` — Accept `db_version: '5.0'`, branch `get_database()` +- `lnt/server/ui/app.py` — Conditional v4/v5 route registration + +--- + +## Phase 1b: Complete v5 DB CRUD Interface — DONE + +**Commit**: `f66311e` on branch `v5` + +Completed all Phase 1b items as part of the Phase 1 commit. All items below +were verified present in the codebase. + +### 1b.1 Strict `format_version` validation + +In `import_run()`, reject if `format_version` is missing (not just if it's +wrong). The design (D6) says it is required. + +### 1b.2 Remove `cursor` parameter from DB methods + +Cursor-based pagination (encoding, decoding, tiebreakers) is an API-layer +concern (see design D10). Remove the `cursor` parameter from: +- `list_commits()` +- `list_runs()` +- `list_field_changes()` +- `list_regressions()` +- `query_time_series()` + +The DB layer provides filtering, sorting, and limit only. + +### 1b.3 Regression state validation + +Add `VALID_REGRESSION_STATES` constant (mapping integers 0-6 to state names) +and validate in `create_regression()` and `update_regression()`. + +### 1b.4 Add missing CRUD methods to `V5TestSuiteDB` + +- `get_test(session, *, id=None, name=None)` — fetch single Test +- `list_tests(session, *, search=None, limit=None)` — list with optional + name prefix search +- `list_samples(session, *, run_id=None, test_id=None, limit=None)` — list + samples with optional filters +- `update_machine(session, machine, *, name=None, parameters=None, **fields)` + — update name, parameters, and/or schema-defined fields +- `delete_field_change(session, field_change_id)` — delete (cascades to + regression indicators) +- `add_regression_indicator(session, regression, field_change)` — add a + single indicator +- `remove_regression_indicator(session, regression_id, field_change_id)` — + remove a single indicator + +### 1b.5 Change ordinal constraint to regular unique + +In `models.py`, change the deferred unique constraint on `ordinal` to a +regular unique constraint. Ordinals are assigned once and not reassigned. + +### 1b.6 Tests + +**Files modified**: +- `tests/server/db/v5/test_time_series.py` — Remove + `TestDeferredOrdinalConstraint` class. Add tests for new CRUD methods, + regression state validation. +- `tests/server/db/v5/test_import.py` — Add test for missing format_version. + +**New tests**: +- get_test by name/id, list_tests, list_tests with search +- list_samples by run, by test +- update_machine name/fields/parameters +- delete_field_change, delete cascades to indicators +- add/remove regression indicator, duplicate indicator rejected +- regression state validation (create and update) +- import_run with missing format_version rejected + +--- + +## Phase 2: v5 API — Rewrite to Use V5TestSuiteDB + +Rewrite every file in `lnt/server/api/v5/` to use `V5TestSuiteDB` (from +`lnt/server/db/v5/`) instead of v4 DB models (from +`lnt.server.db.testsuitedb`). After this phase, the v5 API has zero imports +from v4 DB code. The v5 API is served only on v5 instances +(`db_version: '5.0'`). + +**Implementation order**: Schema renames (2.16-2.24) should be done +alongside or before their corresponding endpoint changes, since endpoints +import from their schema modules. Do each endpoint+schema pair together. + +### 2.1 Middleware (`middleware.py`) + +Replace testsuite resolution: +- Remove `db.check_registry_version(g.db_session)` call (v4 method). + `V5DB.get_suite()` handles staleness checks internally. +- Replace the `if testsuite not in db.testsuite` check + `g.ts = + db.testsuite[testsuite]` with a single call: `g.ts = + db.get_suite(testsuite, g.db_session)`. Return 404 if `None`. This avoids + a TOCTOU race between the `in` check and the dict lookup. +- `g.db` is now always a `V5DB`. No dual-path code. +- `v5_teardown_request()` unchanged (session commit/rollback/close). + +### 2.2 Helpers (`helpers.py`) + +**Delete**: +- `escape_like()` — API no longer builds LIKE queries; DB layer owns search. +- `validate_tag()` — No tags in v5 commits. +- `resolve_metric()` — v4 `SampleField` objects replaced by schema metrics. + +**Replace** `resolve_metric()` with: +```python +def validate_metric_name(ts, field_name): + for m in ts.schema.metrics: + if m.name == field_name: + return + abort_with_error(400, "Unknown metric '%s'" % field_name) +``` + +**Rewrite lookups** to use `V5TestSuiteDB` methods: +- `lookup_machine()` → `ts.get_machine(session, name=name)`, 404 if None. + Remove the "multiple machines" 409 check (v5 enforces uniqueness). +- `lookup_run_by_uuid()` → `ts.get_run(session, uuid=uuid)`. +- `lookup_fieldchange()` → `ts.get_field_change(session, uuid=uuid)`. +- `lookup_test()` → `ts.get_test(session, name=name)`. +- `lookup_regression()` → `ts.get_regression(session, uuid=uuid)`. + +**Rewrite `serialize_run()`**: +```python +def serialize_run(run, ts): + return { + 'uuid': run.uuid, + 'machine': run.machine.name if run.machine else None, + 'commit': run.commit_obj.commit if run.commit_obj else None, + 'submitted_at': run.submitted_at.isoformat() if run.submitted_at else None, + 'run_parameters': dict(run.run_parameters) if run.run_parameters else {}, + } +``` +Changes: `order` dict → `commit` string, `start_time`/`end_time` → +`submitted_at`, `parameters` → `run_parameters`. Note: callers must use +`joinedload(ts.Run.commit_obj)` and `joinedload(ts.Run.machine)` to avoid +N+1 queries. + +**Rewrite `serialize_fieldchange()`**: +```python +def serialize_fieldchange(fc): + return { + 'test': fc.test.name if fc.test else None, + 'machine': fc.machine.name if fc.machine else None, + 'metric': fc.field_name, + 'old_value': fc.old_value, + 'new_value': fc.new_value, + 'start_commit': fc.start_commit.commit if fc.start_commit else None, + 'end_commit': fc.end_commit.commit if fc.end_commit else None, + } +``` +Changes: `fc.field.name` → `fc.field_name`, `start_order`/`end_order` → +`start_commit`/`end_commit`, `run_uuid` dropped (no run FK on v5 +FieldChange). Note: the `uuid` key is added by callers (not the helper) +since different callers use different key names (`uuid` vs +`field_change_uuid`). + +Keep `parse_datetime()` unchanged. + +### 2.3 Endpoint: Orders → Commits + +**Rename** `endpoints/orders.py` → `commits.py`. + +Blueprint name: `'Commits'`, URL prefix unchanged. + +**Delete** all v4 helpers: `_serialize_order_fields()`, +`_serialize_order_summary()`, `_order_detail_url()`, +`_serialize_order_neighbor()`, `_serialize_order_detail()`, +`_lookup_order_by_value()`. + +**New helpers**: +- `_serialize_commit_summary(commit, ts)` — returns `{commit, ordinal, + ...commit_field_values}`. +- `_get_neighbor_commits(session, ts, commit)` — queries nearest + lower/higher ordinal, returns `(prev, next)`. +- `_serialize_commit_detail(commit, testsuite, ts, session)` — summary + + `previous_commit`/`next_commit` neighbors. + +**Endpoints**: +- `GET /commits` — `?search=` param (replaces `tag`/`tag_prefix`). Build + query inline with OR-prefix search on `commit` + searchable + `commit_fields`, pass to `cursor_paginate()`. +- `POST /commits` — Accept `{"commit": "...", ...commit_field_values}`. Use + `ts.get_or_create_commit()`. Return 409 if already exists. +- `GET /commits/` — `ts.get_commit(session, commit=value)`, 404 if + None. Serialize with `_serialize_commit_detail()`. +- `PATCH /commits/` — Accept `{ordinal, ...commit_fields}`. Use + `ts.update_commit()`. Accept `ordinal: null` for `clear_ordinal=True`. +- `DELETE /commits/` — `ts.delete_commit()`. Catch `ValueError` → + 409 (FieldChanges reference it). Return 204. + +### 2.4 Endpoint: Runs (`runs.py`) + +**`POST /runs`** — Complete rewrite: +- Remove `lnt.util.ImportData` import. +- Accept format_version `"5"` (reject anything else). +- Call `ts.import_run(session, parsed_body)` directly. +- Return `{success, run_uuid, result_url}`. +- Remove `_CONFLICT_MAP`/`_MERGE_MAP`. Simplify `on_machine_conflict`: + `"reject"` → `machine_strategy="match"`, `"update"` → `"update"`. +- Drop `on_existing_run` param (v5 always creates a new run). +- Catch `ValueError` → 400. + +**`GET /runs`** — Rewrite filters: +- Replace `order=` filter with `commit=` (string). Look up commit by + `ts.get_commit()` to get `commit_id`. +- Replace `ts.Run.start_time` filter with `ts.Run.submitted_at`. +- Replace `joinedload(ts.Run.order)` with `joinedload(ts.Run.commit_obj)`. +- Use new `serialize_run()`. + +**`GET /runs/`** — Same serialization changes. + +**`DELETE /runs/`** — Use `ts.get_run(session, uuid=...)` then +`ts.delete_run(session, run.id)`. + +### 2.5 Endpoint: Query (`query.py`) + +This is the most complex endpoint. Keep the inline query approach (supports +multi-test disjunction and complex cursor pagination that +`V5TestSuiteDB.query_time_series()` does not handle). + +**Param renames**: `order` → `commit`, `after_order` → `after_commit`, +`before_order` → `before_commit`. + +**Sort fields**: `_ALLOWED_SORT_FIELDS = {'test', 'commit', 'timestamp'}`. + +**`_parse_sort()`**: Change default sort from `[('order', True), ('test', +True)]` to `[('commit', True), ('test', True)]`. Change tiebreaker list +from `('order', 'test')` to `('commit', 'test')`. + +**`_resolve_sort_column()`**: `'commit'` → `ts.Commit.ordinal`, +`'timestamp'` → `ts.Run.submitted_at`. + +**`_coerce_cursor_value()`**: Rename `'order'` branch to `'commit'`, +still returns `int(value)` (now represents ordinal). + +**`_extract_cursor_values()`**: Rename `'order'` branch to `'commit'`, +extract `row_data['ordinal']` instead of `row_data['order_id']`. + +**`_resolve_order()`** → **`_resolve_commit()`**: Look up by +`ts.get_commit(session, commit=value)`. + +**`_resolve_machine()`**: Remove "multiple machines" check (v5 enforces +uniqueness). + +**Metric resolution**: Replace `resolve_metric(ts, name)` (returns +`SampleField`) with `getattr(ts.Sample, name, None)` to get the column. +Remove `from lnt.testing import PASS`. + +**Core query rewrite**: +- Replace `ts.Order` joins with `ts.Commit` joins: + `join(ts.Commit, ts.Run.commit_id == ts.Commit.id)`. +- Remove entire `sample_field.status_field` filter block (no status + pairing in v5). This is the block that imports `PASS`. +- Order range filters: `after_commit.ordinal` / `before_commit.ordinal`. + If commit has no ordinal, abort 400. +- When sorting by `commit`, filter `ts.Commit.ordinal.isnot(None)`. +- Serialize: `commit` string + `ordinal` int instead of `order` dict. + Use `'_ordinal'` as internal cursor key (was `'_order_id'`). + +**Result row construction**: Change `'_order_id': order.id` to +`'_ordinal': commit_obj.ordinal`. Change cursor extraction at end of +endpoint to use `'ordinal'` key. + +**Remove** `from lnt.testing import PASS`. + +### 2.6 Endpoint: Machines (`machines.py`) + +**`_serialize_machine()`** — Rewrite: +- Replace `machine.fields`/`machine.get_field()` with iteration over + `ts.schema.machine_fields` + `getattr(machine, mf.name)`. +- Keep `machine.parameters` JSONB blob. +- Preserve the flat `info` dict shape (schema fields + parameters merged) + to avoid breaking the `MachineResponseSchema` contract. + +**`GET /machines`** — Replace `name_contains`/`name_prefix` with `search`. +Keep offset pagination. + +**`POST /machines`** — Check for existing machine first with +`ts.get_machine(session, name=name)`, abort 409 if found. Then use +`ts.get_or_create_machine()` to create. Split `info` dict into schema +fields vs parameters using `ts.schema.machine_fields`. + +**`PATCH /machines/{name}`** — Use `ts.update_machine()`. + +**`DELETE /machines/{name}`** — Replace entire manual cascade (ChangeIgnore +cleanup, batched run deletion) with `ts.delete_machine(session, machine.id)`. +v5 models have proper CASCADE. Delete all ChangeIgnore references (model +does not exist in v5). + +**`GET /machines/{name}/runs`** — Replace `start_time` → `submitted_at`. +Rename sort parameter value from `-start_time` to `-submitted_at` (update +`MachineRunsQuerySchema` to match). Use new `serialize_run()`. +Add `joinedload(ts.Run.commit_obj)` for serialization. + +### 2.7 Endpoint: Field Changes (`field_changes.py`) + +**Delete** ignore/un-ignore endpoints entirely (`POST .../ignore`, +`DELETE .../ignore`). No ChangeIgnore in v5. + +**`GET /field-changes`** — Remove ChangeIgnore LEFT JOIN. Replace +`resolve_metric()` call and `ts.FieldChange.field_id` filter with direct +string filter: `ts.FieldChange.field_name == metric_name` (no SampleField +lookup needed). Use new `serialize_fieldchange()`. + +**`POST /field-changes`** — Replace `start_order`/`end_order` with +`start_commit`/`end_commit` (strings). Look up commits via +`ts.get_commit()`. Use `ts.create_field_change(session, machine, test, +metric_name, start_commit, end_commit, old_value, new_value)` — pass all +values as arguments (replaces the v4 pattern of constructing then setting +attributes separately). Remove entire `run_uuid` resolution block (no run +FK on v5 FieldChange). + +### 2.8 Endpoint: Regressions (`regressions.py`) + +**State mapping**: Update `STATE_TO_DB` to v5 integer values: +`detected=0, staged=1, active=2, not_to_be_fixed=3, ignored=4, fixed=5, +detected_fixed=6`. + +**`POST /regressions`** — Use `ts.create_regression(session, title, +[fc.id ...], bug=bug, state=state)`. + +**`PATCH /regressions/{uuid}`** — Use `ts.update_regression()`. + +**`DELETE /regressions/{uuid}`** — Use `ts.delete_regression()`. + +**`POST .../merge`** — Use `ts.update_regression()` for state changes. +Keep indicator-moving logic using `ts.RegressionIndicator` queries. + +**`POST .../split`** — Use `ts.create_regression(session, title, [], +...)` then move indicators. + +**`POST .../indicators`** — Use `ts.add_regression_indicator()`. Catch +`IntegrityError` → 409. + +**`DELETE .../indicators/{fc_uuid}`** — Use +`ts.remove_regression_indicator()`. If returns `False`, 404. + +**Metric filter**: Remove `resolve_metric()` call entirely. Filter by +`ts.FieldChange.field_name == metric_name` directly (no SampleField +lookup, no `field_id`). + +### 2.9 Endpoint: Discovery (`discovery.py`) + +Change `'orders'` → `'commits'` in `_suite_links()`. + +### 2.10 Endpoint: Test Suites (`test_suites.py`) + +**Remove all v4 imports**: `lnt.server.db.testsuite`, +`lnt.server.db.testsuitedb`. + +**`_suite_links()`**: `'orders'` → `'commits'`. + +**`_suite_detail()`**: Replace `tsdb.test_suite.__json__()` with +`V5DB._schema_to_dict(tsdb.schema)`. + +**`POST /test-suites`** — Accept v5 schema format (name, metrics, +commit_fields, machine_fields). Parse with +`lnt.server.db.v5.schema.parse_schema()`. Create with +`db.create_suite(session, schema)`. Catch `ValueError` → 409, +`SchemaError` → 400. + +**`DELETE /test-suites/`** — Replace manual v4 metadata cleanup with +`db.delete_suite(session, name)`. + +### 2.11 Endpoint: Tests (`tests.py`) + +Replace `resolve_metric(ts, metric_name)` (returns SampleField with +`.column` attribute) with `getattr(ts.Sample, metric_name, None)` which +returns the Column directly. Replace `field.column.isnot(None)` with +`metric_col.isnot(None)`. + +Keep `name_contains` (substring) and `name_prefix` filter params — these +are useful and not replaced by the DB layer's prefix-only `search`. +Inline the ILIKE escape logic (the DB layer's `_escape_like` is private). + +### 2.12 Endpoint: Samples (`samples.py`) + +**`_serialize_sample()`** — Replace `ts.sample_fields` iteration with +`ts.schema.metrics`: +```python +for metric in ts.schema.metrics: + value = getattr(sample, metric.name, None) + if value is not None: + metrics[metric.name] = value +``` +Remove `has_profile` from response and query params (no profiles in v5). +Also remove the query filter on `ts.Sample.profile_id` (`profile_id` +column does not exist in v5 Sample model). + +### 2.13 Endpoint: Profiles (`profiles.py`) + +Left in place for now. Profiles are not part of the v5 DB layer (design +D13) and the v5 Sample model has no `profile_id` column, so this endpoint +will break once the full API rewrite is complete. It will be removed or +reimplemented at that point. + +### 2.14 Endpoint: Agents / llms.txt (`agents.py`) + +Rewrite `LLMS_TEXT`: replace "Order" with "Commit", explain ordinals, +commit_fields, PATCH workflow. Update URLs (`/orders` → `/commits`), +submission format (format_version `"5"`), `submitted_at`. + +### 2.15 Blueprint registration (`endpoints/__init__.py`) + +Replace `'orders'` with `'commits'` in `_ENDPOINT_MODULES`. Keep +`'profiles'` registered for now (it will break naturally when endpoints +are fully on v5 models; see 2.13). + +### 2.16 Schemas: Orders → Commits + +**Rename** `schemas/orders.py` → `commits.py`. + +New schemas: `CommitSummarySchema` (commit, ordinal, dynamic fields), +`CommitDetailSchema` (adds previous/next neighbors), +`CommitUpdateSchema` (ordinal nullable, dynamic fields), +`CommitCreateSchema`, `CommitListQuerySchema` (search param), +`PaginatedCommitResponseSchema`. + +### 2.17 Schemas: Runs (`schemas/runs.py`) + +`RunResponseSchema`: `order` dict → `commit` string, `start_time`/`end_time` +→ `submitted_at`, `parameters` → `run_parameters`. + +`RunListQuerySchema`: `order` → `commit`, sort references `submitted_at`. + +`RunSubmitQuerySchema`: Remove `on_existing_run`. + +### 2.18 Schemas: Query (`schemas/query.py`) + +`QueryDataPointSchema`: `order` dict → `commit` string + `ordinal` int. + +`QueryEndpointQuerySchema`: `order`/`after_order`/`before_order` → +`commit`/`after_commit`/`before_commit`. + +### 2.19 Schemas: Regressions (`schemas/regressions.py`) + +Update `STATE_TO_DB` integer values to v5 mapping. + +`IndicatorResponseSchema`/`FieldChangeResponseSchema`: +`start_order`/`end_order` → `start_commit`/`end_commit`. Remove `run_uuid`. + +`FieldChangeCreateSchema`: same renames, remove `run_uuid`. + +### 2.20 Schemas: Machines (`schemas/machines.py`) + +`MachineListQuerySchema`: `name_contains`/`name_prefix` → `search`. + +`MachineRunResponseSchema`: `order` → `commit`, `start_time`/`end_time` → +`submitted_at`. + +### 2.21 Schemas: Common (`schemas/common.py`) + +`TestSuiteLinksSchema`: `orders` → `commits`. + +Delete `FieldChangeIgnoreResponseSchema`. + +### 2.22 Schemas: Test Suites (`schemas/test_suites.py`) + +Rewrite `TestSuiteCreateRequestSchema` for v5 format: remove +`format_version`, remove `run_fields`, add `commit_fields` (name, type, +searchable, display). `MetricDefSchema`: add `type` (real/status/hash), +remove `ignore_same_hash`. + +### 2.23 Schemas: Samples (`schemas/samples.py`) + +Remove `has_profile` from `SampleResponseSchema` and +`RunSamplesQuerySchema`. + +### 2.24 Schemas: Profiles (`schemas/profiles.py`) + +Left in place for now (see 2.13). + +### 2.25 Unchanged files + +No changes needed: +- `auth.py` — APIKey model is independent of v4/v5. +- `pagination.py` — Generic cursor pagination, works with any query. +- `etag.py` — Generic ETag support. +- `errors.py` — Generic error handling. +- `__init__.py` (API factory) — Delegates to sub-modules. +- `app.py` — Already branches on `db_version`. +- `config.py` — Already handles `'5.0'`. + +### 2.26 DB model fix: Regression back-reference + +The v5 `Regression` model has no back-reference to `RegressionIndicator`. +The FK `ondelete="CASCADE"` on `RegressionIndicator.regression_id` handles +DB-level cascade, but SQLAlchemy needs a relationship for +`cascade="all, delete-orphan"` to work via `session.delete()`. Add a +`Regression.indicators` relationship in `models.py` (similar to +`FieldChange.regression_indicators`). + +### 2.27 Phase 2 Tests + +#### Test helpers (`v5_test_helpers.py`) — Complete rewrite + +All data creation helpers use v4 constructors. Replace with V5TestSuiteDB +methods: + +- `create_machine()` → `ts.get_or_create_machine(session, name, parameters=..., **fields)` +- `create_order()` → `create_commit()`: `ts.get_or_create_commit(session, commit_str, **metadata)` +- `create_run()` → `ts.create_run(session, machine, commit=commit, submitted_at=..., run_parameters=...)` +- `create_test()` → `ts.get_or_create_test(session, name)` +- `create_sample()` → `ts.create_samples(session, run, [{'test_id': test.id, ...metrics}])[0]` +- `create_fieldchange()` → `ts.create_field_change(session, machine, test, field_name, start_commit, end_commit, old_value, new_value)`. Note: `field` param changes from SampleField object to string. +- `create_regression()` → `ts.create_regression(session, title, [fc.id ...], state=...)` + +The test app factory must create a `V5DB` instance and test suite instead of +v4 metadata tables. + +#### Test file changes + +**`test_orders.py` → `test_commits.py`**: URLs `/orders` → `/commits`. +Assertions: `fields` dict → `commit` string, `tag` → removed, +`previous_order`/`next_order` → `previous_commit`/`next_commit`. New tests: +ordinal PATCH, commit_fields PATCH, `?search=`, DELETE cascade/409. + +**`test_runs.py`**: `order` → `commit`, `start_time`/`end_time` → +`submitted_at`, `parameters` → `run_parameters`. Submission format_version +`"2"` → `"5"` with top-level `commit`. Remove `on_existing_run` tests. + +**`test_query.py`**: `order` → `commit`/`ordinal` in request and response. +`after_order`/`before_order` → `after_commit`/`before_commit`. +`timestamp` → `submitted_at`. + +**`test_machines.py`**: `name_contains`/`name_prefix` → `search`. Run +serialization: `commit`, `submitted_at`. + +**`test_field_changes.py`**: Remove ignore/un-ignore tests. +`start_order`/`end_order` → `start_commit`/`end_commit`. Remove `run_uuid`. + +**`test_regressions.py`**: Indicator assertions: `start_commit`/`end_commit`. +Remove `run_uuid`. Update state integer values. + +**`test_samples.py`**: Remove `has_profile` assertions. + +**`test_profiles.py`**: Left in place for now (see 2.13). Will break when +the samples endpoint no longer exposes `profile_id`. + +**`test_test_suites.py`**: Creation payload → v5 format. Discovery links: +`commits`. + +**`test_discovery.py`**: `orders` → `commits`. + +**`test_integration.py`**: Rewrite `_make_submission_payload()` for v5 +format. All `order` → `commit`, `start_time` → `submitted_at`. New test +classes: `TestOrdinalAssignmentWorkflow`, `TestCommitMetadataWorkflow`, +`TestSearchWorkflow`, `TestMachineUniquenessWorkflow`, +`TestCommitDeletionWorkflow`. + +**`test_agents.py`**: Verify "commit" terminology in llms.txt. + +**`test_helpers.py`**: Update for new `serialize_run()` / +`serialize_fieldchange()` output shapes. + +--- + +## Phase 3: v5 UI — Replace Orders with Commits — DONE + +**Branch**: `v5` + +Updated the entire v5 frontend to use the new commit-based API. All 26 +test files (631 tests) pass. All tox environments pass. + +**Key changes**: +- Types: `OrderSummary/Detail/Neighbor` → `CommitSummary/Detail/Neighbor`. + `RunInfo.order` (dict) → `.commit` (string), `.start_time`/`.end_time` → + `.submitted_at`, `.parameters` → `.run_parameters`. Removed `has_profile` + from `SampleInfo`. `QueryDataPoint.order` (dict) → `.commit` (string) + + `.ordinal`. `SideSelection.order` → `.commit`. +- API: `getOrders/Order/RunsByOrder/OrdersPage` → + `getCommits/Commit/RunsByCommit/CommitsPage`. `searchOrdersByTag` → + `searchCommits` (uses `?search=`). `updateOrderTag` → `updateCommit`. + Query params: `order`→`commit`, `afterOrder`→`afterCommit`. + `getMachines` params: `namePrefix/nameContains` → `search`. +- Pages: `order-detail.ts` → `commit-detail.ts`, tab "Orders" → "Commits", + all order field-dict extraction replaced with direct commit string usage. +- Components: `order-search.ts` → `commit-search.ts`, combobox renamed + (`createOrderPicker` → `createCommitPicker`, etc.), `primaryOrderValue()` + removed. State URL params: `order_a/b` → `commit_a/b`. +- CSS: `.order-*` classes → `.commit-*`. +- Backend test: `/orders/some-value` route → `/commits/some-value`. + +### 3.1 Types (`types.ts`) + +- `OrderSummary` → `CommitSummary`: `{ commit: string, ordinal: number|null, ...metadata }` +- `OrderDetail` → `CommitDetail`: adds previous/next neighbors +- `RunInfo.order` dict → `RunInfo.commit: string` +- `RunInfo.start_time`/`end_time` → `RunInfo.submitted_at` +- `QueryDataPoint.order` dict → `QueryDataPoint.commit: string` +- `MachineRunInfo`: same changes + +### 3.2 API layer (`api.ts`) + +- `getOrder()` → `getCommit()`, URL `/commits/` +- `getRunsByOrder()` → `getRunsByCommit()` +- `updateOrderTag()` → `updateCommitMetadata()` +- New: `updateCommitOrdinal(ts, commit, ordinal)` +- `searchOrdersByTag()` → `searchCommits(ts, search)` +- All run-related functions: expect `commit` string, `submitted_at` + +### 3.3 Pages + +- `order-detail.ts` → `commit-detail.ts` — show commit string, ordinal + (editable), metadata fields, prev/next +- `graph.ts` — X-axis uses commit string, only plot commits with ordinals +- `compare.ts` — select by commit string +- `test-suites.ts` — "Orders" tab → "Commits" tab + +### 3.4 Components and State + +- `order-search.ts` → `commit-search.ts` — uses `?search=` +- `state.ts` — `order_a`/`order_b` → `commit_a`/`commit_b` +- `selection.ts` — order → commit throughout +- `utils.ts` — remove `primaryOrderValue()` (commits are simple strings) +- `graph-data-cache.ts` — cache keys use commit strings +- `combobox.ts` — remove field-dict extraction + +### 3.5 Routes + +- `main.ts` — `/orders/:value` → `/commits/:value` +- `views.py` — update SPA catch-all routes + +### 3.6 Phase 3 Tests + +- Frontend unit tests (vitest): update types, API function references +- SPA route tests: `/commits/:value` renders commit-detail + +--- + +## Phase 4: Migration Tool + +### 4.1 New file: `lnt/lnttool/migrate_v4_to_v5.py` + +CLI command integrated into `lnt admin`: +``` +lnt admin migrate-to-v5 --input --output +``` + +### 4.2 Migration logic + +1. Open v4 database (SQLite or Postgres), read all test suites +2. Create v5 Postgres database +3. Create v5 global tables (`v5_schema`, `v5_schema_version`) +4. For each test suite: + a. Generate v5 schema from v4 suite definition (map order fields → + commit_fields, run_fields → dropped, machine_fields preserved) + b. Insert schema into `v5_schema` table + c. Create per-suite v5 tables + d. Copy Machines (map fields, extra params → JSONB) + e. Convert Orders → Commits: + - `commit` = primary order field value + - `ordinal` = position from linked-list traversal (walk NextOrder + pointers from first order) or from ordinal column if present + - v4 `tag` column → a `label` commit_field if defined in schema + f. Copy Runs (map order_id → commit_id, start_time → submitted_at) + g. Copy Tests (1:1) + h. Copy Samples (map run_id, preserve metric values) + i. Copy FieldChanges (map order FKs → commit FKs, resolve field_id FK + to field_name string via SampleField metatable) + j. Copy Regressions + RegressionIndicators (1:1, preserve UUIDs) +5. Copy global APIKey table + +### 4.3 Phase 4 Tests + +- `tests/lnttool/test_migrate_v4_to_v5.py`: + - Create v4 database with known data + - Run migration + - Verify commit strings, ordinals, run mappings, samples, field changes + - Edge cases: NULL order fields, orphaned runs, empty linked lists + - Idempotency: running twice fails cleanly + +--- + +## Commit Strategy + +1. `ce50c4e` — "Add v5 database layer with Commit model" — DONE +2. Phase 1b — "Complete v5 DB CRUD interface" — DONE (in Phase 1 commit) +3. Phase 2 — "Rewrite v5 API to use v5 DB layer" — DONE +4. Phase 3 — "Update v5 UI: replace orders with commits" — DONE +5. Phase 4 — "Add v4-to-v5 migration tool" + +Each phase is a separate commit. All tox environments must pass before each +commit. diff --git a/docs/v5-submission-guide.md b/docs/v5-submission-guide.md new file mode 100644 index 000000000..018e522ac --- /dev/null +++ b/docs/v5-submission-guide.md @@ -0,0 +1,199 @@ +# Submitting Data to a v5 LNT Instance + +## Quick Start + +A v5 LNT instance uses the v5 REST API exclusively. The submission format +is **different from v4** — you cannot use `format_version: "2"` payloads. + +**Base URL**: `http:///api/v5` + +**Authentication**: `Authorization: Bearer ` header on all write +requests. The token configured via `--api-auth-token` during `lnt create` +acts as an admin-scoped bootstrap token. + +## Step 1: Create a Test Suite + +Before submitting runs, the test suite must exist. + +``` +POST /api/v5/test-suites/ +Authorization: Bearer +Content-Type: application/json +``` + +```json +{ + "name": "nts", + "metrics": [ + {"name": "execution_time", "type": "real", "bigger_is_better": false, + "display_name": "Execution Time", "unit": "seconds", "unit_abbrev": "s"}, + {"name": "compile_time", "type": "real", "bigger_is_better": false}, + {"name": "compile_status", "type": "status"}, + {"name": "execution_status", "type": "status"}, + {"name": "score", "type": "real", "bigger_is_better": true}, + {"name": "hash", "type": "hash"} + ], + "commit_fields": [ + {"name": "llvm_project_revision", "searchable": true, "display": true} + ], + "machine_fields": [ + {"name": "hardware", "searchable": true}, + {"name": "os", "searchable": true} + ] +} +``` + +Returns 201 on success, 409 if it already exists. Requires `manage` scope. + +**Metric types**: `real` (float), `status` (integer), `hash` (string). + +**commit_fields**: Optional typed metadata columns on the Commit table. +`display: true` means the UI shows this field's value instead of the raw +commit string. `searchable: true` enables `?search=` prefix matching. + +**machine_fields**: Optional typed columns on the Machine table. + +**Note**: There is no `run_fields` section in v5. The v4 concept of +`run_fields` with `order: true` is replaced by the built-in `commit` +concept. Extra run metadata goes in `run_parameters` (JSONB). + +## Step 2: Submit Runs + +``` +POST /api/v5//runs?on_machine_conflict=update +Authorization: Bearer +Content-Type: application/json +``` + +### v5 Submission Format + +```json +{ + "format_version": "5", + "machine": { + "name": "my-machine", + "hardware": "x86_64", + "os": "linux" + }, + "commit": "abc123def456", + "commit_fields": { + "llvm_project_revision": "abc123def456" + }, + "run_parameters": { + "build_config": "Release", + "start_time": "2024-01-15T10:30:00" + }, + "tests": [ + { + "name": "nts.suite/benchmark", + "execution_time": 1.23, + "compile_time": 0.45 + } + ] +} +``` + +### Required Fields + +| Field | Type | Description | +|-------|------|-------------| +| `format_version` | string | Must be `"5"` (not `"2"`) | +| `machine` | object | Must have `name`. Other keys matching `machine_fields` go to columns; unknown keys go to `parameters` JSONB | +| `commit` | string | Groups runs. Can be a git SHA, version number, or ad-hoc label | +| `tests` | array | Each entry has `name` plus metric values matching the schema. Metric values may be scalars or arrays — arrays create multiple samples per test (e.g. `"execution_time": [0.1, 0.2]`) | + +### Optional Fields + +| Field | Type | Description | +|-------|------|-------------| +| `commit_fields` | object | Metadata for the commit. First-write-wins (use PATCH to update later) | +| `run_parameters` | object | Stored as JSONB on the Run. Put `start_time`, `end_time`, `build_config`, etc. here | + +### Query Parameters + +| Param | Values | Default | Description | +|-------|--------|---------|-------------| +| `on_machine_conflict` | `match`, `update` | `match` | `match` rejects if machine fields differ; `update` overwrites | + +### Response (201) + +```json +{ + "success": true, + "run_uuid": "a1b2c3d4-...", + "result_url": "/api/v5/nts/runs/a1b2c3d4-..." +} +``` + +## Converting v4 Data to v5 Format + +When scraping from a v4 server (e.g. lnt.llvm.org), the scraped data uses +the v4 format. Here's how to convert: + +| v4 Field | v5 Field | +|----------|----------| +| `format_version: "2"` | `format_version: "5"` | +| `run.llvm_project_revision` (or primary order field) | `commit` (top-level string) | +| `run.llvm_project_revision` | `commit_fields.llvm_project_revision` | +| `run.start_time`, `run.end_time` | `run_parameters.start_time`, `run_parameters.end_time` | +| Other `run.*` fields | `run_parameters.*` or `commit_fields.*` | +| `machine.name` | `machine.name` (unchanged) | +| Machine info fields | `machine.*` (unchanged — schema fields go to columns, rest to parameters) | +| `tests[].name` | `tests[].name` (unchanged) | +| `tests[].` | `tests[].` (unchanged) | + +**Key difference**: In v4, the order/revision was inside `run`. In v5, +it's `commit` at the top level. The `run` section is gone entirely — +use `run_parameters` for any extra run metadata. + +## Step 3: Assign Ordinals (Optional) + +Commits are created without ordinals (they have no position in the +time series). To enable time-series graphing, assign ordinals: + +``` +PATCH /api/v5//commits/ +Authorization: Bearer +Content-Type: application/json + +{"ordinal": 12345} +``` + +Ordinals must be unique integers. They define the x-axis order on graphs. +Commits without ordinals are excluded from time-series queries sorted by +commit. + +## Step 4: Verify + +```bash +# List machines +curl http://localhost:8000/api/v5//machines + +# List runs (newest first) +curl "http://localhost:8000/api/v5//runs?sort=-submitted_at&limit=10" + +# Get run detail +curl http://localhost:8000/api/v5//runs/ + +# Get samples for a run +curl http://localhost:8000/api/v5//runs//samples + +# List commits +curl http://localhost:8000/api/v5//commits +``` + +All GET endpoints allow unauthenticated access by default. + +## Important Notes + +- **format_version must be "5"** — the v5 API rejects `"2"`. +- **No `on_existing_run` param** — v5 always creates a new run. Multiple + runs per machine+commit are allowed. +- **Null metrics** — omit metrics with null values from the tests array. + Only include metrics that have actual values. +- **commit_fields are first-write-wins** — if the commit already exists, + `commit_fields` in the submission are ignored. Use + `PATCH /api/v5//commits/` to update. +- **No regression auto-detection** — v5 does not auto-detect regressions. + Use `POST /api/v5//field-changes` to create them externally. +- **Postgres required** — v5 instances only work with PostgreSQL. diff --git a/lnt/lnttool/create.py b/lnt/lnttool/create.py index e397087c8..84ad1f0b5 100644 --- a/lnt/lnttool/create.py +++ b/lnt/lnttool/create.py @@ -38,7 +38,7 @@ # The list of available databases, and their properties. At a minimum, there # should be a 'default' entry for the default database. databases = { - 'default' : { 'path' : %(default_db)r }, + 'default' : { %(db_version_line)s'path' : %(default_db)r }, } # The LNT email configuration. @@ -90,9 +90,12 @@ help="authentication token for the REST API") @click.option("--show-sql", is_flag=True, help="show SQL statements executed during construction") +@click.option("--db-version", default="0.4", type=click.Choice(["0.4", "5.0"]), + show_default=True, + help="database version (5.0 requires PostgreSQL)") def action_create(instance_path, name, config, wsgi, tmp_dir, db_dir, profile_dir, default_db, secret_key, url, api_auth_token, - show_sql): + show_sql, db_version): """create an LLVM nightly test installation \b @@ -133,6 +136,14 @@ def action_create(instance_path, name, config, wsgi, tmp_dir, db_dir, else: api_auth_token_line = "# api_auth_token = 'secret'" + if db_version == '5.0': + db_version_line = "'db_version': '5.0', " + if lnt.server.db.util.path_has_no_database_type(db_dir): + print("warning: v5 requires PostgreSQL. The default SQLite " + "path will not work. Use --db-dir with a PostgreSQL URI.") + else: + db_version_line = "" + os.mkdir(instance_path) os.mkdir(tmp_path) os.mkdir(schemas_path) diff --git a/lnt/server/config.py b/lnt/server/config.py index 06caf5032..14a56558b 100644 --- a/lnt/server/config.py +++ b/lnt/server/config.py @@ -6,7 +6,7 @@ import re import tempfile -import lnt.server.db.v4db +import lnt.server.db.v4db # noqa: F401 -- used via dotted access in get_database() class EmailConfig: @@ -63,26 +63,29 @@ def from_data(baseDir, config_data, default_email_config, baseline_revision = config_data.get('baseline_revision', default_baseline_revision) db_version = config_data.get('db_version', '0.4') - if db_version != '0.4': + if db_version not in ('0.4', '5.0'): raise NotImplementedError("unable to load version %r database" % ( db_version)) return DBInfo(dbPath, config_data.get('shadow_import', None), email_config, - baseline_revision) + baseline_revision, + db_version=db_version) @staticmethod def dummy_instance(): return DBInfo("sqlite:///:memory:", None, EmailConfig(False, '', '', []), 0) - def __init__(self, path, shadow_import, email_config, baseline_revision): + def __init__(self, path, shadow_import, email_config, baseline_revision, + db_version='0.4'): self.config = None self.path = path self.shadow_import = shadow_import self.email_config = email_config self.baseline_revision = baseline_revision + self.db_version = db_version def __str__(self): return "DBInfo(" + self.path + ")" @@ -191,6 +194,10 @@ def get_database(self, name): if db_entry is None: return None + if db_entry.db_version == '5.0': + from lnt.server.db.v5 import V5DB + return V5DB(db_entry.path, self) + return lnt.server.db.v4db.V4DB(db_entry.path, self, db_entry.baseline_revision) diff --git a/lnt/server/db/v5/__init__.py b/lnt/server/db/v5/__init__.py new file mode 100644 index 000000000..610a4ab6b --- /dev/null +++ b/lnt/server/db/v5/__init__.py @@ -0,0 +1,1255 @@ +""" +v5 database layer. + +Provides :class:`V5DB` (engine, sessions, schema loading) and +:class:`V5TestSuiteDB` (per-suite CRUD operations). + +Postgres only. No imports from v4 DB code. +""" + +from __future__ import annotations + +import datetime +import json +import uuid as uuid_module +from typing import Any + +import sqlalchemy +import sqlalchemy.exc +import sqlalchemy.orm +from sqlalchemy import or_ + +from .models import ( + SuiteModels, + V5Schema, + V5SchemaVersion, + create_global_tables, + create_suite_models, +) +from .schema import TestSuiteSchema, parse_schema + +DEFAULT_LIMIT = 1000 + +# Regression state values (see design D5). +REGRESSION_STATES = { + 0: "detected", + 1: "staged", + 2: "active", + 3: "not_to_be_fixed", + 4: "ignored", + 5: "fixed", + 6: "detected_fixed", +} +VALID_REGRESSION_STATES = frozenset(REGRESSION_STATES) + + +def _escape_like(s: str) -> str: + """Escape SQL special characters for use in ILIKE patterns. + + Replaces ``\\``, ``%``, and ``_`` with their escaped equivalents + so the caller can safely use ``ESCAPE '\\'`` in the ILIKE clause. + """ + return s.replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_") + + +class V5DB: + """Top-level database handle for a v5 LNT instance. + + Owns the SQLAlchemy engine, session factory, and a dict of per-suite + :class:`V5TestSuiteDB` wrappers. Schemas are stored in the database + (``v5_schema`` table), not on the filesystem. + """ + + def __init__(self, path: str, config: Any): + self.path = path + self.config = config + self.engine = sqlalchemy.create_engine( + path, + pool_size=10, + max_overflow=20, + pool_pre_ping=True, + pool_recycle=3600, + ) + self.sessionmaker = sqlalchemy.orm.sessionmaker(self.engine) + self.testsuite: dict[str, V5TestSuiteDB] = {} + self._schema_version: int | None = None + + create_global_tables(self.engine) + self._ensure_schema_version_row() + self._load_schemas_from_db() + + # -- schema storage -------------------------------------------------------- + + @staticmethod + def _schema_to_dict(schema: TestSuiteSchema) -> dict[str, Any]: + """Serialize a TestSuiteSchema to a JSON-serializable dict.""" + return { + "name": schema.name, + "metrics": [ + { + "name": m.name, + "type": m.type, + **({"display_name": m.display_name} if m.display_name else {}), + **({"unit": m.unit} if m.unit else {}), + **({"unit_abbrev": m.unit_abbrev} if m.unit_abbrev else {}), + **({"bigger_is_better": True} if m.bigger_is_better else {}), + } + for m in schema.metrics + ], + "commit_fields": [ + { + "name": cf.name, + **({"type": cf.type} if cf.type != "default" else {}), + **({"searchable": True} if cf.searchable else {}), + **({"display": True} if cf.display else {}), + } + for cf in schema.commit_fields + ], + "machine_fields": [ + { + "name": mf.name, + **({"searchable": True} if mf.searchable else {}), + } + for mf in schema.machine_fields + ], + } + + def _ensure_schema_version_row(self) -> None: + """Make sure the v5_schema_version table has its single row.""" + session = self.sessionmaker() + try: + row = session.query(V5SchemaVersion).get(1) + if row is None: + row = V5SchemaVersion(id=1, version=0) + session.add(row) + session.commit() + except Exception: + session.rollback() + raise + finally: + session.close() + + def _load_schemas_from_db(self) -> None: + """Read all rows from ``v5_schema``, parse each into a + TestSuiteSchema, build models, and create per-suite tables.""" + session = self.sessionmaker() + try: + rows = session.query(V5Schema).all() + ver = session.query(V5SchemaVersion).get(1) + self._schema_version = ver.version if ver else 0 + + self.testsuite.clear() + for row in rows: + data = json.loads(row.schema_json) + schema = parse_schema(data) + models = create_suite_models(schema) + models.base.metadata.create_all(self.engine) + tsdb = V5TestSuiteDB(self, schema, models) + self.testsuite[schema.name] = tsdb + finally: + session.close() + + def _check_schema_version(self, session: sqlalchemy.orm.Session) -> bool: + """Return True if the cached schema version is stale.""" + row = session.query(V5SchemaVersion).get(1) + current = row.version if row else 0 + return current != self._schema_version + + @staticmethod + def _bump_schema_version(session: sqlalchemy.orm.Session) -> None: + """Increment the version counter (caller must commit).""" + row = session.query(V5SchemaVersion).get(1) + if row is None: + row = V5SchemaVersion(id=1, version=1) + session.add(row) + else: + row.version = row.version + 1 + + def get_suite(self, name: str, session: sqlalchemy.orm.Session | None = None) -> V5TestSuiteDB | None: + """Return a suite by name, transparently reloading if stale.""" + if session is not None: + if self._check_schema_version(session): + self._load_schemas_from_db() + else: + session = self.sessionmaker() + try: + if self._check_schema_version(session): + self._load_schemas_from_db() + finally: + session.close() + return self.testsuite.get(name) + + def create_suite( + self, + session: sqlalchemy.orm.Session, + schema: TestSuiteSchema, + ) -> V5TestSuiteDB: + """Persist a new suite schema in the DB and create its tables.""" + if schema.name in self.testsuite: + raise ValueError(f"suite {schema.name!r} already exists") + schema_dict = self._schema_to_dict(schema) + row = V5Schema( + name=schema.name, + schema_json=json.dumps(schema_dict), + created_at=datetime.datetime.now(datetime.timezone.utc), + ) + session.add(row) + self._bump_schema_version(session) + session.flush() + + models = create_suite_models(schema) + models.base.metadata.create_all(self.engine) + tsdb = V5TestSuiteDB(self, schema, models) + self.testsuite[schema.name] = tsdb + + ver = session.query(V5SchemaVersion).get(1) + self._schema_version = ver.version if ver else 0 + + return tsdb + + def delete_suite( + self, + session: sqlalchemy.orm.Session, + name: str, + ) -> None: + """Delete a suite schema from the DB and drop its tables.""" + tsdb = self.testsuite.get(name) + if tsdb is None: + raise ValueError(f"suite {name!r} does not exist") + + row = session.query(V5Schema).get(name) + if row is not None: + session.delete(row) + self._bump_schema_version(session) + session.flush() + + tsdb.models.base.metadata.drop_all(self.engine) + del self.testsuite[name] + + ver = session.query(V5SchemaVersion).get(1) + self._schema_version = ver.version if ver else 0 + + # -- session helpers ------------------------------------------------------- + + def make_session(self, expire_on_commit: bool = True) -> sqlalchemy.orm.Session: + """Return a new SQLAlchemy session.""" + return self.sessionmaker(expire_on_commit=expire_on_commit) + + def close(self) -> None: + self.engine.dispose() + + +def _validate_regression_state(state: int) -> None: + """Raise ValueError if *state* is not a valid regression state.""" + if state not in VALID_REGRESSION_STATES: + raise ValueError( + f"invalid regression state {state!r}; " + f"valid states: {sorted(VALID_REGRESSION_STATES)}" + ) + + +class V5TestSuiteDB: + """Per-suite database operations for the v5 layer. + + Provides a clean CRUD interface consumed by the v5 API endpoints. + """ + + def __init__(self, v5db: V5DB, schema: TestSuiteSchema, models: SuiteModels): + self.v5db = v5db + self.name = schema.name + self.schema = schema + self.models = models + self._commit_field_names: frozenset[str] = frozenset(cf.name for cf in schema.commit_fields) + self._machine_field_names: frozenset[str] = frozenset(mf.name for mf in schema.machine_fields) + self._metric_names: frozenset[str] = frozenset(m.name for m in schema.metrics) + self.Commit = models.Commit + self.Machine = models.Machine + self.Run = models.Run + self.Test = models.Test + self.Sample = models.Sample + self.FieldChange = models.FieldChange + self.Regression = models.Regression + self.RegressionIndicator = models.RegressionIndicator + + # =================================================================== + # Commits + # =================================================================== + + def get_or_create_commit( + self, + session: sqlalchemy.orm.Session, + commit: str, + **metadata: Any, + ): + """Return existing Commit or create a new one. + + *metadata* keys correspond to ``commit_fields`` defined in the schema. + On creation, all metadata is stored. If the commit already exists, + metadata is NOT overwritten (first-write-wins). + """ + if not commit: + raise ValueError("commit string must be non-empty") + existing = ( + session.query(self.Commit) + .filter(self.Commit.commit == commit) + .first() + ) + if existing is not None: + return existing + + obj = self.Commit() + obj.commit = commit + # ordinal is always NULL on creation + for key, value in metadata.items(): + if key in self._commit_field_names: + setattr(obj, key, value) + session.add(obj) + try: + session.flush() + except sqlalchemy.exc.IntegrityError: + session.rollback() + # Race condition: another session created it; fetch and return. + existing = ( + session.query(self.Commit) + .filter(self.Commit.commit == commit) + .first() + ) + if existing is None: + raise # pragma: no cover + return existing + return obj + + def get_commit( + self, + session: sqlalchemy.orm.Session, + *, + id: int | None = None, + commit: str | None = None, + ): + """Fetch a single Commit by id or commit string. Returns None if not found.""" + q = session.query(self.Commit) + if id is not None: + return q.filter(self.Commit.id == id).first() + if commit is not None: + return q.filter(self.Commit.commit == commit).first() + raise ValueError("must specify id or commit") + + def update_commit( + self, + session: sqlalchemy.orm.Session, + commit_obj, + *, + ordinal: int | None = None, + clear_ordinal: bool = False, + **commit_fields: Any, + ): + """Update mutable fields on a Commit. + + *ordinal* sets the ordering position. Pass ``clear_ordinal=True`` + to explicitly set ordinal to ``None``. + Additional keyword arguments correspond to ``commit_fields`` defined + in the schema and update the matching columns. + """ + if clear_ordinal: + commit_obj.ordinal = None + elif ordinal is not None: + commit_obj.ordinal = ordinal + for key, value in commit_fields.items(): + if key in self._commit_field_names: + setattr(commit_obj, key, value) + session.flush() + return commit_obj + + def list_commits( + self, + session: sqlalchemy.orm.Session, + *, + search: str | None = None, + ordinal_range: tuple[int, int] | None = None, + limit: int | None = None, + ) -> list: + """List commits with optional search / ordinal-range filtering. + + *search* performs OR prefix-matching across the ``commit`` column and + all ``searchable`` commit_fields. + """ + q = session.query(self.Commit) + + if search: + escaped = _escape_like(search) + prefix = f"{escaped}%" + clauses = [self.Commit.commit.ilike(prefix, escape="\\")] + for cf in self.schema.searchable_commit_fields: + col = getattr(self.Commit, cf.name) + clauses.append(col.ilike(prefix, escape="\\")) + q = q.filter(or_(*clauses)) + + if ordinal_range is not None: + lo, hi = ordinal_range + q = q.filter( + self.Commit.ordinal.isnot(None), + self.Commit.ordinal >= lo, + self.Commit.ordinal <= hi, + ) + + q = q.order_by(self.Commit.id) + + q = q.limit(limit if limit is not None else DEFAULT_LIMIT) + + return q.all() + + def delete_commit( + self, + session: sqlalchemy.orm.Session, + commit_id: int, + ) -> None: + """Delete a commit by ID (cascades to runs and samples). + + Raises ``ValueError`` if any FieldChanges reference this commit + (via ``start_commit_id`` or ``end_commit_id``). Those must be + deleted first. + """ + commit = session.query(self.Commit).get(commit_id) + if commit is None: + return + + fc_count = ( + session.query(self.FieldChange) + .filter( + or_( + self.FieldChange.start_commit_id == commit_id, + self.FieldChange.end_commit_id == commit_id, + ) + ) + .count() + ) + if fc_count > 0: + raise ValueError( + f"Cannot delete commit {commit_id}: " + f"{fc_count} FieldChange(s) reference it; " + f"delete them first" + ) + + session.delete(commit) + session.flush() + + # =================================================================== + # Machines + # =================================================================== + + def get_or_create_machine( + self, + session: sqlalchemy.orm.Session, + name: str, + *, + strategy: str = "reject", + parameters: dict[str, Any] | None = None, + **fields: Any, + ): + """Get or create a Machine by name. + + With ``strategy='reject'`` (default), raises ``ValueError`` if the + existing machine's schema-defined fields differ from *fields*. + """ + existing = ( + session.query(self.Machine) + .filter(self.Machine.name == name) + .first() + ) + if existing is not None: + if strategy == "reject": + for key, value in fields.items(): + if key not in self._machine_field_names or value is None: + continue + existing_value = getattr(existing, key, None) + if existing_value is not None and existing_value != value: + raise ValueError( + f"Machine {name!r}: field {key!r} changed " + f"from {existing_value!r} to {value!r}" + ) + if existing_value is None: + setattr(existing, key, value) + # Merge parameters + if parameters: + merged = dict(existing.parameters or {}) + merged.update(parameters) + existing.parameters = merged + elif strategy == "update": + for key, value in fields.items(): + if key in self._machine_field_names and value is not None: + setattr(existing, key, value) + if parameters: + merged = dict(existing.parameters or {}) + merged.update(parameters) + existing.parameters = merged + return existing + + machine = self.Machine() + machine.name = name + for key, value in fields.items(): + if key in self._machine_field_names: + setattr(machine, key, value) + machine.parameters = parameters or {} + session.add(machine) + session.flush() + return machine + + def get_machine( + self, + session: sqlalchemy.orm.Session, + *, + id: int | None = None, + name: str | None = None, + ): + """Fetch a single Machine by id or name.""" + q = session.query(self.Machine) + if id is not None: + return q.filter(self.Machine.id == id).first() + if name is not None: + return q.filter(self.Machine.name == name).first() + raise ValueError("must specify id or name") + + def list_machines( + self, + session: sqlalchemy.orm.Session, + *, + search: str | None = None, + limit: int | None = None, + ) -> list: + """List machines with optional search. + + *search* performs OR prefix-matching across ``name`` and all + ``searchable`` machine_fields. + """ + q = session.query(self.Machine) + if search: + escaped = _escape_like(search) + prefix = f"{escaped}%" + clauses = [self.Machine.name.ilike(prefix, escape="\\")] + for mf in self.schema.searchable_machine_fields: + col = getattr(self.Machine, mf.name) + clauses.append(col.ilike(prefix, escape="\\")) + q = q.filter(or_(*clauses)) + return q.order_by(self.Machine.id).limit(limit if limit is not None else DEFAULT_LIMIT).all() + + def delete_machine(self, session: sqlalchemy.orm.Session, machine_id: int) -> None: + """Delete a machine by ID (cascades to runs and samples).""" + machine = session.query(self.Machine).get(machine_id) + if machine is not None: + session.delete(machine) + session.flush() + + def update_machine( + self, + session: sqlalchemy.orm.Session, + machine, + *, + name: str | None = None, + parameters: dict[str, Any] | None = None, + **fields: Any, + ): + """Update mutable fields on a Machine. + + *name* renames the machine (caller must ensure uniqueness). + *parameters* replaces the JSONB blob. + Additional keyword arguments update schema-defined machine_fields. + """ + if name is not None: + machine.name = name + if parameters is not None: + machine.parameters = parameters + for key, value in fields.items(): + if key in self._machine_field_names: + setattr(machine, key, value) + session.flush() + return machine + + # =================================================================== + # Runs + # =================================================================== + + def create_run( + self, + session: sqlalchemy.orm.Session, + machine, + *, + commit, + submitted_at: datetime.datetime | None = None, + run_parameters: dict[str, Any] | None = None, + ): + """Create a new Run attached to *machine* and *commit*. + + *commit* is required -- every run must have a commit (design D2). + """ + if commit is None: + raise ValueError("commit is required (every run must have a commit)") + run = self.Run() + run.uuid = str(uuid_module.uuid4()) + run.machine_id = machine.id + run.commit_id = commit.id + run.submitted_at = submitted_at or datetime.datetime.now(datetime.timezone.utc) + run.run_parameters = run_parameters or {} + session.add(run) + session.flush() + return run + + def get_run( + self, + session: sqlalchemy.orm.Session, + *, + id: int | None = None, + uuid: str | None = None, + ): + """Fetch a single Run by id or uuid.""" + q = session.query(self.Run) + if id is not None: + return q.filter(self.Run.id == id).first() + if uuid is not None: + return q.filter(self.Run.uuid == uuid).first() + raise ValueError("must specify id or uuid") + + def list_runs( + self, + session: sqlalchemy.orm.Session, + *, + machine_id: int | None = None, + commit_id: int | None = None, + limit: int | None = None, + ) -> list: + """List runs with optional filters.""" + q = session.query(self.Run) + if machine_id is not None: + q = q.filter(self.Run.machine_id == machine_id) + if commit_id is not None: + q = q.filter(self.Run.commit_id == commit_id) + q = q.order_by(self.Run.id) + q = q.limit(limit if limit is not None else DEFAULT_LIMIT) + return q.all() + + def delete_run(self, session: sqlalchemy.orm.Session, run_id: int) -> None: + """Delete a run by ID (cascades to samples).""" + run = session.query(self.Run).get(run_id) + if run is not None: + session.delete(run) + session.flush() + + # =================================================================== + # Tests & Samples + # =================================================================== + + def get_or_create_test(self, session: sqlalchemy.orm.Session, name: str): + """Get or create a Test by name. + + TODO: This is called per test entry in _parse_tests_data(), causing + one SELECT per test name (N+1). For large submissions (~3000 tests), + batch with a single SELECT ... WHERE name IN (...) + bulk INSERT. + """ + existing = ( + session.query(self.Test) + .filter(self.Test.name == name) + .first() + ) + if existing is not None: + return existing + test = self.Test() + test.name = name + session.add(test) + try: + session.flush() + except sqlalchemy.exc.IntegrityError: + session.rollback() + return ( + session.query(self.Test) + .filter(self.Test.name == name) + .first() + ) + return test + + def get_test( + self, + session: sqlalchemy.orm.Session, + *, + id: int | None = None, + name: str | None = None, + ): + """Fetch a single Test by id or name. Returns None if not found.""" + q = session.query(self.Test) + if id is not None: + return q.filter(self.Test.id == id).first() + if name is not None: + return q.filter(self.Test.name == name).first() + raise ValueError("must specify id or name") + + def list_tests( + self, + session: sqlalchemy.orm.Session, + *, + search: str | None = None, + limit: int | None = None, + ) -> list: + """List tests with optional name prefix search.""" + q = session.query(self.Test) + if search: + escaped = _escape_like(search) + q = q.filter(self.Test.name.ilike(f"{escaped}%", escape="\\")) + q = q.order_by(self.Test.id) + q = q.limit(limit if limit is not None else DEFAULT_LIMIT) + return q.all() + + def list_samples( + self, + session: sqlalchemy.orm.Session, + *, + run_id: int | None = None, + test_id: int | None = None, + limit: int | None = None, + ) -> list: + """List samples with optional filters.""" + q = session.query(self.Sample) + if run_id is not None: + q = q.filter(self.Sample.run_id == run_id) + if test_id is not None: + q = q.filter(self.Sample.test_id == test_id) + q = q.order_by(self.Sample.id) + q = q.limit(limit if limit is not None else DEFAULT_LIMIT) + return q.all() + + def create_samples( + self, + session: sqlalchemy.orm.Session, + run, + samples: list[dict[str, Any]], + ) -> list: + """Create Sample rows for *run*. + + Each dict in *samples* must have ``test_id`` plus metric fields. + """ + metric_names = self._metric_names + created = [] + for sample_data in samples: + s = self.Sample() + s.run_id = run.id + s.test_id = sample_data["test_id"] + for key, value in sample_data.items(): + if key in ("test_id",): + continue + if key in metric_names: + setattr(s, key, value) + created.append(s) + session.add_all(created) + session.flush() + return created + + # =================================================================== + # Time-series query + # =================================================================== + + def query_time_series( + self, + session: sqlalchemy.orm.Session, + machine, + test, + metric: str, + *, + commit_range: tuple[int, int] | None = None, + time_range: tuple[datetime.datetime, datetime.datetime] | None = None, + sort: str | None = None, + limit: int | None = None, + ) -> list[dict[str, Any]]: + """Query time-series data for a (machine, test, metric) triple. + + Returns a list of dicts with keys: ``commit``, ``ordinal``, + ``value``, ``run_id``, ``submitted_at``. + + *commit_range* filters by ordinal [lo, hi]. When sorting by ordinal, + commits without ordinals are excluded. + """ + metric_col = getattr(self.Sample, metric, None) + if metric_col is None: + raise ValueError(f"unknown metric {metric!r}") + + q = ( + session.query( + self.Commit.commit, + self.Commit.ordinal, + metric_col.label("value"), + self.Run.id.label("run_id"), + self.Run.submitted_at, + ) + .select_from(self.Sample) + .join(self.Run, self.Sample.run_id == self.Run.id) + .join(self.Commit, self.Run.commit_id == self.Commit.id) + .filter(self.Run.machine_id == machine.id) + .filter(self.Sample.test_id == test.id) + .filter(metric_col.isnot(None)) + ) + + if commit_range is not None: + lo, hi = commit_range + q = q.filter( + self.Commit.ordinal.isnot(None), + self.Commit.ordinal >= lo, + self.Commit.ordinal <= hi, + ) + + if time_range is not None: + start, end = time_range + q = q.filter( + self.Run.submitted_at >= start, + self.Run.submitted_at <= end, + ) + + if sort == "ordinal": + q = q.filter(self.Commit.ordinal.isnot(None)) + q = q.order_by(self.Commit.ordinal) + elif sort == "submitted_at": + q = q.order_by(self.Run.submitted_at) + else: + q = q.order_by(self.Run.id) + + if limit is not None: + q = q.limit(limit) + + results = [] + for row in q.all(): + results.append({ + "commit": row.commit, + "ordinal": row.ordinal, + "value": row.value, + "run_id": row.run_id, + "submitted_at": row.submitted_at, + }) + return results + + def query_trends( + self, + session: sqlalchemy.orm.Session, + metric: str, + *, + machine_ids: list[int] | None = None, + time_range: tuple[datetime.datetime, datetime.datetime] | None = None, + ) -> list[dict[str, Any]]: + """Query geomean-aggregated trend data grouped by (machine, commit). + + Computes ``exp(avg(ln(metric)))`` over all samples for each + (machine, commit) pair. Only positive metric values are included + (required for ``ln``). + + Returns a list of dicts with keys: ``machine_name``, ``commit``, + ``ordinal``, ``value``, ``timestamp``. + """ + from sqlalchemy import func + + metric_col = getattr(self.Sample, metric, None) + if metric_col is None: + raise ValueError(f"unknown metric {metric!r}") + + q = ( + session.query( + self.Machine.name.label("machine_name"), + self.Commit.id.label("commit_id"), + self.Commit.commit, + self.Commit.ordinal, + func.exp(func.avg(func.ln(metric_col))).label("value"), + func.max(self.Run.submitted_at).label("submitted_at"), + ) + .select_from(self.Sample) + .join(self.Run, self.Sample.run_id == self.Run.id) + .join(self.Commit, self.Run.commit_id == self.Commit.id) + .join(self.Machine, self.Run.machine_id == self.Machine.id) + .filter(metric_col > 0) + ) + + if machine_ids: + q = q.filter(self.Machine.id.in_(machine_ids)) + + if time_range is not None: + start, end = time_range + q = q.filter(self.Run.submitted_at >= start) + q = q.filter(self.Run.submitted_at <= end) + + q = q.group_by( + self.Machine.name, self.Commit.id, + self.Commit.commit, self.Commit.ordinal, + ) + + # Order by ordinal when available, falling back to commit id. + # NULLs sort last so that commits without ordinals appear at the end. + q = q.order_by( + self.Machine.name, + self.Commit.ordinal.asc().nullslast(), + self.Commit.id, + ) + + results = [] + for row in q.all(): + results.append({ + "machine_name": row.machine_name, + "commit": row.commit, + "ordinal": row.ordinal, + "value": row.value, + "submitted_at": row.submitted_at, + }) + return results + + # =================================================================== + # FieldChanges (CRUD only) + # =================================================================== + + def create_field_change( + self, + session: sqlalchemy.orm.Session, + machine, + test, + field_name: str, + start_commit, + end_commit, + old_value: float | None, + new_value: float | None, + ): + """Create a FieldChange record.""" + fc = self.FieldChange() + fc.uuid = str(uuid_module.uuid4()) + fc.machine_id = machine.id + fc.test_id = test.id + fc.field_name = field_name + fc.start_commit_id = start_commit.id + fc.end_commit_id = end_commit.id + fc.old_value = old_value + fc.new_value = new_value + session.add(fc) + session.flush() + return fc + + def get_field_change( + self, + session: sqlalchemy.orm.Session, + *, + id: int | None = None, + uuid: str | None = None, + ): + """Fetch a single FieldChange by id or uuid.""" + q = session.query(self.FieldChange) + if id is not None: + return q.filter(self.FieldChange.id == id).first() + if uuid is not None: + return q.filter(self.FieldChange.uuid == uuid).first() + raise ValueError("must specify id or uuid") + + def list_field_changes( + self, + session: sqlalchemy.orm.Session, + *, + machine=None, + test=None, + metric: str | None = None, + limit: int | None = None, + ) -> list: + """List field changes with optional filters.""" + q = session.query(self.FieldChange) + if machine is not None: + q = q.filter(self.FieldChange.machine_id == machine.id) + if test is not None: + q = q.filter(self.FieldChange.test_id == test.id) + if metric is not None: + q = q.filter(self.FieldChange.field_name == metric) + return q.order_by(self.FieldChange.id).limit(limit if limit is not None else DEFAULT_LIMIT).all() + + def delete_field_change( + self, + session: sqlalchemy.orm.Session, + field_change_id: int, + ) -> None: + """Delete a field change by ID (cascades to regression indicators).""" + fc = session.query(self.FieldChange).get(field_change_id) + if fc is not None: + session.delete(fc) + session.flush() + + def create_regression( + self, + session: sqlalchemy.orm.Session, + title: str, + field_change_ids: list[int], + *, + bug: str | None = None, + state: int = 0, + ): + """Create a Regression with the given FieldChange indicators.""" + _validate_regression_state(state) + reg = self.Regression() + reg.uuid = str(uuid_module.uuid4()) + reg.title = title + reg.bug = bug + reg.state = state + session.add(reg) + session.flush() + + indicators = [] + for fc_id in field_change_ids: + ri = self.RegressionIndicator() + ri.regression_id = reg.id + ri.field_change_id = fc_id + indicators.append(ri) + session.add_all(indicators) + session.flush() + return reg + + def get_regression( + self, + session: sqlalchemy.orm.Session, + *, + id: int | None = None, + uuid: str | None = None, + ): + """Fetch a single Regression by id or uuid.""" + q = session.query(self.Regression) + if id is not None: + return q.filter(self.Regression.id == id).first() + if uuid is not None: + return q.filter(self.Regression.uuid == uuid).first() + raise ValueError("must specify id or uuid") + + def update_regression( + self, + session: sqlalchemy.orm.Session, + regression, + *, + title: str | None = None, + bug: str | None = None, + state: int | None = None, + ): + """Update mutable fields on a Regression.""" + if title is not None: + regression.title = title + if bug is not None: + regression.bug = bug + if state is not None: + _validate_regression_state(state) + regression.state = state + session.flush() + return regression + + def list_regressions( + self, + session: sqlalchemy.orm.Session, + *, + state: int | None = None, + limit: int | None = None, + ) -> list: + """List regressions, optionally filtered by state.""" + q = session.query(self.Regression) + if state is not None: + q = q.filter(self.Regression.state == state) + return q.order_by(self.Regression.id).limit(limit if limit is not None else DEFAULT_LIMIT).all() + + def delete_regression( + self, + session: sqlalchemy.orm.Session, + regression_id: int, + ) -> None: + """Delete a regression by ID (cascades to indicators).""" + reg = session.query(self.Regression).get(regression_id) + if reg is not None: + session.delete(reg) + session.flush() + + def add_regression_indicator( + self, + session: sqlalchemy.orm.Session, + regression, + field_change, + ): + """Add a FieldChange as an indicator on a Regression. + + Returns the created RegressionIndicator. Raises + ``sqlalchemy.exc.IntegrityError`` if the pair already exists. + """ + ri = self.RegressionIndicator() + ri.regression_id = regression.id + ri.field_change_id = field_change.id + session.add(ri) + session.flush() + return ri + + def remove_regression_indicator( + self, + session: sqlalchemy.orm.Session, + regression_id: int, + field_change_id: int, + ) -> bool: + """Remove a single indicator from a regression. + + Returns True if an indicator was removed, False if none matched. + """ + count = ( + session.query(self.RegressionIndicator) + .filter( + self.RegressionIndicator.regression_id == regression_id, + self.RegressionIndicator.field_change_id == field_change_id, + ) + .delete() + ) + if count: + session.flush() + return count > 0 + + # =================================================================== + # Bulk import (run submission) -- helpers + # =================================================================== + + def _parse_machine_data( + self, + data: dict[str, Any], + ) -> tuple[str, dict[str, Any], dict[str, Any]]: + """Extract machine name, schema-defined fields, and extra parameters + from the submission data. + + Returns ``(name, fields, params)``. + """ + machine_data = data.get("machine", {}) + machine_name = machine_data.get("name") + if not machine_name: + raise ValueError("machine.name is required") + + valid_machine_fields = self._machine_field_names + machine_fields: dict[str, Any] = {} + machine_params: dict[str, Any] = {} + for key, value in machine_data.items(): + if key == "name": + continue + if key in valid_machine_fields: + machine_fields[key] = value + else: + machine_params[key] = value + + return machine_name, machine_fields, machine_params + + def _parse_commit_data( + self, + session: sqlalchemy.orm.Session, + data: dict[str, Any], + ): + """Extract and get-or-create the Commit from the submission data. + + Returns the Commit object. + """ + commit_str = data.get("commit") + if not commit_str: + raise ValueError("commit is required (every run must have a commit)") + commit_field_data = data.get("commit_fields", {}) + return self.get_or_create_commit(session, commit_str, **commit_field_data) + + def _parse_tests_data( + self, + session: sqlalchemy.orm.Session, + data: dict[str, Any], + run, + ) -> list: + """Parse test entries and create all samples in a single batch. + + Metric values may be scalars or lists. A list value (e.g. + ``"execution_time": [0.1, 0.2]``) creates one Sample per element. + All list values in a single test entry must have the same length; + scalar values are repeated across the resulting Samples. + + Returns the list of created Sample objects. + """ + tests_data = data.get("tests", []) + metric_names = self._metric_names + all_samples: list[dict[str, Any]] = [] + + for test_entry in tests_data: + test_name = test_entry.get("name") + if not test_name: + raise ValueError("each test entry must have a 'name'") + + test = self.get_or_create_test(session, test_name) + + metrics: dict[str, Any] = {} + for key, value in test_entry.items(): + if key == "name": + continue + if key in metric_names: + metrics[key] = value + + list_len = None + for key, value in metrics.items(): + if isinstance(value, list): + if list_len is None: + list_len = len(value) + elif len(value) != list_len: + raise ValueError( + f"metric lists for test '{test_name}' have " + f"inconsistent lengths" + ) + + if list_len is not None and list_len == 0: + raise ValueError( + f"metric lists for test '{test_name}' must not be empty" + ) + + if list_len is None: + sample_dict: dict[str, Any] = {"test_id": test.id} + sample_dict.update(metrics) + all_samples.append(sample_dict) + else: + for i in range(list_len): + sample_dict = {"test_id": test.id} + for key, value in metrics.items(): + sample_dict[key] = value[i] if isinstance(value, list) else value + all_samples.append(sample_dict) + + if all_samples: + return self.create_samples(session, run, all_samples) + return [] + + # =================================================================== + # Bulk import (run submission) + # =================================================================== + + def import_run( + self, + session: sqlalchemy.orm.Session, + data: dict[str, Any], + *, + machine_strategy: str = "reject", + ): + """Import a run from the v5 submission format. + + See the implementation plan (Phase 1c) for the expected JSON schema. + + Returns the created Run. + """ + fmt = data.get("format_version") + if fmt != "5": + raise ValueError( + f"format_version is required and must be '5', got {fmt!r}" + ) + + # -- Machine -------------------------------------------------------- + machine_name, machine_fields, machine_params = self._parse_machine_data(data) + machine = self.get_or_create_machine( + session, + machine_name, + strategy=machine_strategy, + parameters=machine_params if machine_params else None, + **machine_fields, + ) + + # -- Commit (required) ---------------------------------------------- + commit_obj = self._parse_commit_data(session, data) + + # -- Run ------------------------------------------------------------ + run_parameters = data.get("run_parameters", {}) + run = self.create_run( + session, + machine, + commit=commit_obj, + run_parameters=run_parameters, + ) + + # -- Tests & Samples (batched) -------------------------------------- + self._parse_tests_data(session, data, run) + + return run diff --git a/lnt/server/db/v5/models.py b/lnt/server/db/v5/models.py new file mode 100644 index 000000000..8017a2281 --- /dev/null +++ b/lnt/server/db/v5/models.py @@ -0,0 +1,402 @@ +""" +Dynamic SQLAlchemy model factory for v5 per-suite tables. + +Creates model classes at runtime based on a :class:`TestSuiteSchema`, producing +per-suite tables such as ``nts_Commit``, ``nts_Machine``, etc. + +Postgres only. SQLAlchemy 1.3 style (Column, relation, declarative_base). +""" + +from __future__ import annotations + +import uuid as uuid_module +from dataclasses import dataclass +from typing import Any + +import sqlalchemy +import sqlalchemy.ext.declarative +from sqlalchemy import ( + Column, + DateTime, + Float, + ForeignKey, + Index, + Integer, + String, + Text, + UniqueConstraint, +) +from sqlalchemy.dialects.postgresql import JSONB +from sqlalchemy.orm import relation + +from .schema import TestSuiteSchema + + +# --------------------------------------------------------------------------- +# Global tables (shared across all suites) +# --------------------------------------------------------------------------- + +_global_base = sqlalchemy.ext.declarative.declarative_base() + + +class V5Schema(_global_base): # type: ignore[misc] + """Persisted test suite schema (one row per suite).""" + __tablename__ = "v5_schema" + name = Column("name", String(256), primary_key=True) + schema_json = Column("schema_json", Text, nullable=False) + created_at = Column("created_at", DateTime, nullable=False) + + +class V5SchemaVersion(_global_base): # type: ignore[misc] + """Single-row counter for multi-process schema cache invalidation.""" + __tablename__ = "v5_schema_version" + id = Column("id", Integer, primary_key=True) + version = Column("version", Integer, nullable=False) + + +def create_global_tables(engine) -> None: + """Create the global ``v5_schema`` and ``v5_schema_version`` tables.""" + _global_base.metadata.create_all(engine) + + +# --------------------------------------------------------------------------- +# Column type mapping +# --------------------------------------------------------------------------- + +_COMMIT_FIELD_TYPE_MAP: dict[str, Any] = { + "default": lambda: String(256), + "text": lambda: Text, + "integer": lambda: Integer, + "datetime": lambda: DateTime, +} + +_METRIC_TYPE_MAP: dict[str, Any] = { + "real": lambda: Float, + "status": lambda: Integer, + "hash": lambda: String(256), +} + + +# --------------------------------------------------------------------------- +# Public dataclass holding all generated models for a single test suite +# --------------------------------------------------------------------------- + +@dataclass +class SuiteModels: + """Container for all SQLAlchemy model classes of a single test suite.""" + base: Any # declarative base + Commit: Any = None + Machine: Any = None + Run: Any = None + Test: Any = None + Sample: Any = None + FieldChange: Any = None + Regression: Any = None + RegressionIndicator: Any = None + + +# --------------------------------------------------------------------------- +# Factory +# --------------------------------------------------------------------------- + +def create_suite_models(schema: TestSuiteSchema) -> SuiteModels: + """Build SQLAlchemy model classes for the given *schema*. + + Each suite gets its own ``declarative_base()`` so that per-suite tables + can be created independently. + """ + base = sqlalchemy.ext.declarative.declarative_base() + prefix = schema.name + + # ----------------------------------------------------------------------- + # Commit + # ----------------------------------------------------------------------- + commit_attrs: dict[str, Any] = { + "__tablename__": f"{prefix}_Commit", + "id": Column("id", Integer, primary_key=True), + "commit": Column("commit", String(256), unique=True, nullable=False), + "ordinal": Column("ordinal", Integer, nullable=True), + "__table_args__": ( + UniqueConstraint( + "ordinal", + name=f"{prefix}_Commit_ordinal_unique", + ), + ), + } + # Dynamic commit_fields columns + for cf in schema.commit_fields: + if cf.name in commit_attrs: + raise ValueError( + f"commit_fields name {cf.name!r} collides with a built-in column" + ) + col_type = _COMMIT_FIELD_TYPE_MAP[cf.type]() + commit_attrs[cf.name] = Column( + cf.name, col_type, nullable=True, index=cf.searchable, + ) + + Commit = type("Commit", (base,), commit_attrs) + + # ----------------------------------------------------------------------- + # Machine + # ----------------------------------------------------------------------- + machine_attrs: dict[str, Any] = { + "__tablename__": f"{prefix}_Machine", + "id": Column("id", Integer, primary_key=True), + "name": Column("name", String(256), unique=True, nullable=False), + "parameters": Column( + "parameters", JSONB, nullable=False, + server_default=sqlalchemy.text("'{}'::jsonb"), + ), + } + for mf in schema.machine_fields: + if mf.name in machine_attrs: + raise ValueError( + f"machine_fields name {mf.name!r} collides with a built-in column" + ) + machine_attrs[mf.name] = Column( + mf.name, String(256), nullable=True, index=mf.searchable, + ) + + Machine = type("Machine", (base,), machine_attrs) + + # ----------------------------------------------------------------------- + # Run + # ----------------------------------------------------------------------- + run_attrs: dict[str, Any] = { + "__tablename__": f"{prefix}_Run", + "id": Column("id", Integer, primary_key=True), + "uuid": Column( + "uuid", String(36), unique=True, nullable=False, index=True, + default=lambda: str(uuid_module.uuid4()), + ), + "machine_id": Column( + "machine_id", Integer, + ForeignKey(f"{prefix}_Machine.id", ondelete="CASCADE"), + nullable=False, index=True, + ), + "commit_id": Column( + "commit_id", Integer, + ForeignKey(f"{prefix}_Commit.id", ondelete="CASCADE"), + nullable=False, index=True, + ), + "submitted_at": Column("submitted_at", DateTime, nullable=False, index=True), + "run_parameters": Column( + "run_parameters", JSONB, nullable=False, + server_default=sqlalchemy.text("'{}'::jsonb"), + ), + "machine": relation("Machine", foreign_keys=f"{prefix}_Run.c.machine_id"), + "commit_obj": relation("Commit", foreign_keys=f"{prefix}_Run.c.commit_id"), + } + + Run = type("Run", (base,), run_attrs) + + # Compound index on (machine_id, commit_id) for time-series join pattern + Index( + f"ix_{prefix}_Run_machine_id_commit_id", + Run.machine_id, Run.commit_id, # type: ignore[attr-defined] + ) + + # ----------------------------------------------------------------------- + # Test + # ----------------------------------------------------------------------- + test_attrs: dict[str, Any] = { + "__tablename__": f"{prefix}_Test", + "id": Column("id", Integer, primary_key=True), + "name": Column("name", String(256), unique=True, nullable=False), + } + Test = type("Test", (base,), test_attrs) + + # ----------------------------------------------------------------------- + # Sample + # ----------------------------------------------------------------------- + sample_attrs: dict[str, Any] = { + "__tablename__": f"{prefix}_Sample", + "id": Column("id", Integer, primary_key=True), + "run_id": Column( + "run_id", Integer, + ForeignKey(f"{prefix}_Run.id", ondelete="CASCADE"), + nullable=False, + ), + "test_id": Column( + "test_id", Integer, + ForeignKey(f"{prefix}_Test.id", ondelete="CASCADE"), + nullable=False, + ), + "run": relation("Run", foreign_keys=f"{prefix}_Sample.c.run_id"), + "test": relation("Test", foreign_keys=f"{prefix}_Sample.c.test_id"), + } + # Dynamic metric columns + for metric in schema.metrics: + if metric.name in sample_attrs: + raise ValueError( + f"metric name {metric.name!r} collides with a built-in column" + ) + col_type = _METRIC_TYPE_MAP[metric.type]() + sample_attrs[metric.name] = Column(metric.name, col_type, nullable=True) + + Sample = type("Sample", (base,), sample_attrs) + + # Covers the most common sample query: "all metrics for a given run+test pair" + # Compound index on (run_id, test_id) + Index( + f"ix_{prefix}_Sample_run_id_test_id", + Sample.run_id, Sample.test_id, # type: ignore[attr-defined] + ) + + # ----------------------------------------------------------------------- + # FieldChange + # ----------------------------------------------------------------------- + fc_attrs: dict[str, Any] = { + "__tablename__": f"{prefix}_FieldChange", + "id": Column("id", Integer, primary_key=True), + "uuid": Column( + "uuid", String(36), unique=True, nullable=False, index=True, + default=lambda: str(uuid_module.uuid4()), + ), + "test_id": Column( + "test_id", Integer, + ForeignKey(f"{prefix}_Test.id"), + nullable=False, index=True, + ), + "machine_id": Column( + "machine_id", Integer, + ForeignKey(f"{prefix}_Machine.id"), + nullable=False, index=True, + ), + "field_name": Column("field_name", String(256), nullable=False), + "start_commit_id": Column( + "start_commit_id", Integer, + ForeignKey(f"{prefix}_Commit.id"), + nullable=False, index=True, + ), + "end_commit_id": Column( + "end_commit_id", Integer, + ForeignKey(f"{prefix}_Commit.id"), + nullable=False, index=True, + ), + "old_value": Column("old_value", Float, nullable=True), + "new_value": Column("new_value", Float, nullable=True), + "test": relation("Test", foreign_keys=f"{prefix}_FieldChange.c.test_id"), + "machine": relation("Machine", foreign_keys=f"{prefix}_FieldChange.c.machine_id"), + "start_commit": relation( + "Commit", + foreign_keys=f"{prefix}_FieldChange.c.start_commit_id", + ), + "end_commit": relation( + "Commit", + foreign_keys=f"{prefix}_FieldChange.c.end_commit_id", + ), + } + FieldChange = type("FieldChange", (base,), fc_attrs) + + # Covers regression lookup: "field changes for a specific test on a machine" + # Compound index on (machine_id, test_id, field_name) + Index( + f"ix_{prefix}_FieldChange_machine_test_field", + FieldChange.machine_id, FieldChange.test_id, FieldChange.field_name, # type: ignore[attr-defined] + ) + + # ----------------------------------------------------------------------- + # Regression + # ----------------------------------------------------------------------- + reg_attrs: dict[str, Any] = { + "__tablename__": f"{prefix}_Regression", + "id": Column("id", Integer, primary_key=True), + "uuid": Column( + "uuid", String(36), unique=True, nullable=False, index=True, + default=lambda: str(uuid_module.uuid4()), + ), + "title": Column("title", String(256), nullable=True), + "bug": Column("bug", String(256), nullable=True), + "state": Column("state", Integer, nullable=False, index=True), + } + Regression = type("Regression", (base,), reg_attrs) + + # ----------------------------------------------------------------------- + # RegressionIndicator + # ----------------------------------------------------------------------- + ri_attrs: dict[str, Any] = { + "__tablename__": f"{prefix}_RegressionIndicator", + "id": Column("id", Integer, primary_key=True), + "regression_id": Column( + "regression_id", Integer, + ForeignKey(f"{prefix}_Regression.id", ondelete="CASCADE"), + nullable=False, index=True, + ), + "field_change_id": Column( + "field_change_id", Integer, + ForeignKey(f"{prefix}_FieldChange.id", ondelete="CASCADE"), + nullable=False, index=True, + ), + "__table_args__": ( + UniqueConstraint("regression_id", "field_change_id", + name=f"uq_{prefix}_ri_regression_fieldchange"), + ), + "regression": relation( + "Regression", + foreign_keys=f"{prefix}_RegressionIndicator.c.regression_id", + ), + "field_change": relation( + "FieldChange", + foreign_keys=f"{prefix}_RegressionIndicator.c.field_change_id", + ), + } + RegressionIndicator = type("RegressionIndicator", (base,), ri_attrs) + + # ----------------------------------------------------------------------- + # Back-references (added after all classes exist) + # ----------------------------------------------------------------------- + Machine.runs = relation( # type: ignore[attr-defined] + Run, + foreign_keys=[Run.machine_id], # type: ignore[attr-defined] + back_populates="machine", + cascade="all, delete-orphan", + passive_deletes=True, + ) + Commit.runs = relation( # type: ignore[attr-defined] + Run, + foreign_keys=[Run.commit_id], # type: ignore[attr-defined] + back_populates="commit_obj", + cascade="all, delete-orphan", + passive_deletes=True, + ) + Run.samples = relation( # type: ignore[attr-defined] + Sample, + foreign_keys=[Sample.run_id], # type: ignore[attr-defined] + back_populates="run", + cascade="all, delete-orphan", + passive_deletes=True, + ) + Test.samples = relation( # type: ignore[attr-defined] + Sample, + foreign_keys=[Sample.test_id], # type: ignore[attr-defined] + back_populates="test", + cascade="all, delete-orphan", + passive_deletes=True, + ) + FieldChange.regression_indicators = relation( # type: ignore[attr-defined] + RegressionIndicator, + foreign_keys=[RegressionIndicator.field_change_id], # type: ignore[attr-defined] + back_populates="field_change", + cascade="all, delete-orphan", + passive_deletes=True, + ) + Regression.indicators = relation( # type: ignore[attr-defined] + RegressionIndicator, + foreign_keys=[RegressionIndicator.regression_id], # type: ignore[attr-defined] + back_populates="regression", + cascade="all, delete-orphan", + passive_deletes=True, + ) + + return SuiteModels( + base=base, + Commit=Commit, + Machine=Machine, + Run=Run, + Test=Test, + Sample=Sample, + FieldChange=FieldChange, + Regression=Regression, + RegressionIndicator=RegressionIndicator, + ) diff --git a/lnt/server/db/v5/schema.py b/lnt/server/db/v5/schema.py new file mode 100644 index 000000000..4bfeacf12 --- /dev/null +++ b/lnt/server/db/v5/schema.py @@ -0,0 +1,230 @@ +""" +v5 YAML schema parser. + +Parses test suite schema files that define commit_fields, machine_fields, +and metrics for a v5 test suite. Produces dataclass-based schema objects +used by the dynamic model factory. +""" + +from __future__ import annotations + +from dataclasses import dataclass, field +from pathlib import Path +from typing import Any + +import yaml + + +# Column names that are always present on the Commit table and therefore +# cannot be used as user-defined commit_field names. +_RESERVED_COMMIT_NAMES = frozenset({"id", "commit", "ordinal"}) + +# Column names that are always present on the Machine table. +_RESERVED_MACHINE_NAMES = frozenset({"id", "name", "parameters"}) + +# Column names that are always present on the Sample table and therefore +# cannot be used as metric names. +_RESERVED_SAMPLE_NAMES = frozenset({"id", "run_id", "test_id"}) + +# Supported column types for commit_fields and the SQLAlchemy type they map to. +# The mapping to actual SQLAlchemy types is done in models.py; here we just +# validate the string values. +VALID_COMMIT_FIELD_TYPES = frozenset({"default", "text", "integer", "datetime"}) + +# Supported metric types (maps to Sample column types). +VALID_METRIC_TYPES = frozenset({"real", "status", "hash"}) + + +@dataclass(frozen=True, slots=True) +class CommitField: + """A user-defined metadata column on the Commit table.""" + name: str + type: str = "default" # default | text | integer | datetime + searchable: bool = False + display: bool = False + + +@dataclass(frozen=True, slots=True) +class MachineField: + """A user-defined column on the Machine table.""" + name: str + searchable: bool = False + + +@dataclass(frozen=True, slots=True) +class Metric: + """A metric column on the Sample table.""" + name: str + type: str = "real" # real | status | hash + display_name: str | None = None + unit: str | None = None + unit_abbrev: str | None = None + bigger_is_better: bool = False + + +@dataclass(frozen=True, slots=True) +class TestSuiteSchema: + """Parsed v5 test suite schema.""" + name: str + metrics: list[Metric] = field(default_factory=list) + commit_fields: list[CommitField] = field(default_factory=list) + machine_fields: list[MachineField] = field(default_factory=list) + # Cached filtered lists (set in __post_init__) + _searchable_commit_fields: list[CommitField] = field( + default_factory=list, init=False, repr=False, compare=False, + ) + _searchable_machine_fields: list[MachineField] = field( + default_factory=list, init=False, repr=False, compare=False, + ) + + def __post_init__(self) -> None: + object.__setattr__( + self, + "_searchable_commit_fields", + [f for f in self.commit_fields if f.searchable], + ) + object.__setattr__( + self, + "_searchable_machine_fields", + [f for f in self.machine_fields if f.searchable], + ) + + @property + def searchable_commit_fields(self) -> list[CommitField]: + return self._searchable_commit_fields + + @property + def searchable_machine_fields(self) -> list[MachineField]: + return self._searchable_machine_fields + + +class SchemaError(Exception): + """Raised when a schema file is invalid.""" + + +def _parse_commit_fields(raw: list[dict[str, Any]]) -> list[CommitField]: + fields: list[CommitField] = [] + seen: set[str] = set() + for entry in raw: + name = entry.get("name") + if not name or not isinstance(name, str): + raise SchemaError("commit_fields entry missing 'name'") + if name in _RESERVED_COMMIT_NAMES: + raise SchemaError( + f"commit_fields name {name!r} is reserved " + f"(cannot use {sorted(_RESERVED_COMMIT_NAMES)})" + ) + if name in seen: + raise SchemaError(f"duplicate commit_fields name: {name!r}") + seen.add(name) + + ftype = entry.get("type", "default") + if ftype not in VALID_COMMIT_FIELD_TYPES: + raise SchemaError( + f"commit_fields[{name!r}] has unknown type {ftype!r}; " + f"valid types: {sorted(VALID_COMMIT_FIELD_TYPES)}" + ) + searchable = bool(entry.get("searchable", False)) + display = bool(entry.get("display", False)) + fields.append(CommitField( + name=name, type=ftype, searchable=searchable, display=display, + )) + + # At most one commit_field may have display=True (design D4). + display_count = sum(1 for f in fields if f.display) + if display_count > 1: + display_names = [f.name for f in fields if f.display] + raise SchemaError( + f"at most one commit_field may have display=true, " + f"but found {display_count}: {display_names}" + ) + + return fields + + +def _parse_machine_fields(raw: list[dict[str, Any]]) -> list[MachineField]: + fields: list[MachineField] = [] + seen: set[str] = set() + for entry in raw: + name = entry.get("name") + if not name or not isinstance(name, str): + raise SchemaError("machine_fields entry missing 'name'") + if name in _RESERVED_MACHINE_NAMES: + raise SchemaError( + f"machine_fields name {name!r} is reserved " + f"(cannot use {sorted(_RESERVED_MACHINE_NAMES)})" + ) + if name in seen: + raise SchemaError(f"duplicate machine_fields name: {name!r}") + seen.add(name) + + searchable = bool(entry.get("searchable", False)) + fields.append(MachineField(name=name, searchable=searchable)) + return fields + + +def _parse_metrics(raw: list[dict[str, Any]]) -> list[Metric]: + metrics: list[Metric] = [] + seen: set[str] = set() + for entry in raw: + name = entry.get("name") + if not name or not isinstance(name, str): + raise SchemaError("metrics entry missing 'name'") + if name in _RESERVED_SAMPLE_NAMES: + raise SchemaError( + f"metric name {name!r} is reserved " + f"(cannot use {sorted(_RESERVED_SAMPLE_NAMES)})" + ) + if name in seen: + raise SchemaError(f"duplicate metric name: {name!r}") + seen.add(name) + + mtype = entry.get("type", "real").lower() + if mtype not in VALID_METRIC_TYPES: + raise SchemaError( + f"metrics[{name!r}] has unknown type {mtype!r}; " + f"valid types: {sorted(VALID_METRIC_TYPES)}" + ) + metrics.append(Metric( + name=name, + type=mtype, + display_name=entry.get("display_name"), + unit=entry.get("unit"), + unit_abbrev=entry.get("unit_abbrev"), + bigger_is_better=bool(entry.get("bigger_is_better", False)), + )) + return metrics + + +def parse_schema(data: dict[str, Any]) -> TestSuiteSchema: + """Parse a raw YAML dict into a :class:`TestSuiteSchema`. + + Raises :class:`SchemaError` on validation failures. + """ + name = data.get("name") + if not name or not isinstance(name, str): + raise SchemaError("schema missing required 'name' field") + + metrics = _parse_metrics(data.get("metrics", [])) + commit_fields = _parse_commit_fields(data.get("commit_fields", [])) + machine_fields = _parse_machine_fields(data.get("machine_fields", [])) + + return TestSuiteSchema( + name=name, + metrics=metrics, + commit_fields=commit_fields, + machine_fields=machine_fields, + ) + + +def load_schema_file(path: str | Path) -> TestSuiteSchema: + """Load and parse a YAML schema file. + + Raises :class:`SchemaError` on validation failures or + :class:`FileNotFoundError` / :class:`yaml.YAMLError` on I/O / parse errors. + """ + with open(path) as f: + data = yaml.safe_load(f) + if not isinstance(data, dict): + raise SchemaError(f"schema file {path} does not contain a YAML mapping") + return parse_schema(data) diff --git a/lnt/server/ui/app.py b/lnt/server/ui/app.py index 0d85dd4a2..99a1a9514 100644 --- a/lnt/server/ui/app.py +++ b/lnt/server/ui/app.py @@ -145,16 +145,28 @@ def create_with_instance(instance): # Load the application configuration. app.load_config(instance) - # Load the application routes. - app.register_blueprint(lnt.server.ui.views.frontend) - - # Load the v5 frontend (comparison SPA, etc.). - from lnt.server.ui.v5 import v5_frontend - app.register_blueprint(v5_frontend) - - # Load the flaskRESTful API. - app.api = Api(app) - load_api_resources(app.api) + # Determine the db_version from the default database entry to decide + # which routes to register. When multiple databases exist we use the + # default ('default') entry; fall back to '0.4' if absent. + _default_db_info = instance.config.databases.get('default') + _db_version = getattr(_default_db_info, 'db_version', '0.4') \ + if _default_db_info else '0.4' + + if _db_version != '5.0': + # v4 mode: register the legacy views and flaskRESTful API. + app.register_blueprint(lnt.server.ui.views.frontend) + + # Load the v5 frontend (comparison SPA, etc.). + from lnt.server.ui.v5 import v5_frontend + app.register_blueprint(v5_frontend) + + # Load the flaskRESTful API. + app.api = Api(app) + load_api_resources(app.api) + else: + # v5-only mode: skip legacy v4 views entirely. + from lnt.server.ui.v5 import v5_frontend + app.register_blueprint(v5_frontend) @app.before_request def set_session(): @@ -191,6 +203,9 @@ def internal_server_error(e): from lnt.server.api.v5 import create_v5_api app.v5_api = create_v5_api(app) + # Store the db_version on the app for use by request handlers. + app.db_version = _db_version + return app @staticmethod diff --git a/tests/server/db/v5/__init__.py b/tests/server/db/v5/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/server/db/v5/test_crud.py b/tests/server/db/v5/test_crud.py new file mode 100644 index 000000000..31269e0dc --- /dev/null +++ b/tests/server/db/v5/test_crud.py @@ -0,0 +1,648 @@ +# RUN: rm -rf %t.instance %t.pg.log +# RUN: %{utils}/with_postgres.sh %t.pg.log \ +# RUN: python %s +# END. + +import os +import sys +import unittest + +import sqlalchemy +import sqlalchemy.exc +import sqlalchemy.orm + +from lnt.server.db.v5.schema import parse_schema +from lnt.server.db.v5.models import create_suite_models +from lnt.server.db.v5 import V5TestSuiteDB, VALID_REGRESSION_STATES + + +def _make_engine(): + db_uri = os.environ.get('LNT_TEST_DB_URI') + db_name = os.environ.get('LNT_TEST_DB_NAME') + if not db_uri or not db_name: + raise unittest.SkipTest( + "LNT_TEST_DB_URI / LNT_TEST_DB_NAME not set") + return sqlalchemy.create_engine(f"{db_uri}/{db_name}") + + +def _test_schema(): + return parse_schema({ + "name": "ts", + "metrics": [ + {"name": "execution_time", "type": "real"}, + ], + "commit_fields": [ + {"name": "author", "searchable": True}, + ], + "machine_fields": [ + {"name": "hardware", "searchable": True}, + ], + }) + + +class _CRUDTestBase(unittest.TestCase): + """Shared setup for CRUD method tests.""" + + @classmethod + def setUpClass(cls): + cls.engine = _make_engine() + cls.schema = _test_schema() + cls.suite_models = create_suite_models(cls.schema) + cls.suite_models.base.metadata.drop_all(cls.engine) + cls.suite_models.base.metadata.create_all(cls.engine) + cls.Session = sqlalchemy.orm.sessionmaker(cls.engine) + + class _FakeV5DB: + pass + cls.tsdb = V5TestSuiteDB(_FakeV5DB(), cls.schema, cls.suite_models) + + @classmethod + def tearDownClass(cls): + cls.suite_models.base.metadata.drop_all(cls.engine) + cls.engine.dispose() + + +class TestUpdateCommit(unittest.TestCase): + + @classmethod + def setUpClass(cls): + cls.engine = _make_engine() + cls.schema = _test_schema() + cls.suite_models = create_suite_models(cls.schema) + cls.suite_models.base.metadata.drop_all(cls.engine) + cls.suite_models.base.metadata.create_all(cls.engine) + cls.Session = sqlalchemy.orm.sessionmaker(cls.engine) + + class _FakeV5DB: + pass + cls.tsdb = V5TestSuiteDB(_FakeV5DB(), cls.schema, cls.suite_models) + + @classmethod + def tearDownClass(cls): + cls.suite_models.base.metadata.drop_all(cls.engine) + cls.engine.dispose() + + def test_set_ordinal(self): + session = self.Session() + c = self.tsdb.get_or_create_commit(session, "uc-ord-1") + self.assertIsNone(c.ordinal) + + self.tsdb.update_commit(session, c, ordinal=100) + session.commit() + + fetched = self.tsdb.get_commit(session, commit="uc-ord-1") + self.assertEqual(fetched.ordinal, 100) + session.close() + + def test_clear_ordinal(self): + session = self.Session() + c = self.tsdb.get_or_create_commit(session, "uc-ord-2") + self.tsdb.update_commit(session, c, ordinal=200) + session.commit() + self.assertEqual(c.ordinal, 200) + + self.tsdb.update_commit(session, c, clear_ordinal=True) + session.commit() + + fetched = self.tsdb.get_commit(session, commit="uc-ord-2") + self.assertIsNone(fetched.ordinal) + session.close() + + def test_set_metadata(self): + session = self.Session() + c = self.tsdb.get_or_create_commit(session, "uc-meta-1") + self.assertIsNone(c.author) + + self.tsdb.update_commit(session, c, author="Alice") + session.commit() + + fetched = self.tsdb.get_commit(session, commit="uc-meta-1") + self.assertEqual(fetched.author, "Alice") + session.close() + + def test_overwrite_metadata(self): + session = self.Session() + c = self.tsdb.get_or_create_commit(session, "uc-meta-2", author="Bob") + session.commit() + self.assertEqual(c.author, "Bob") + + self.tsdb.update_commit(session, c, author="Charlie") + session.commit() + + fetched = self.tsdb.get_commit(session, commit="uc-meta-2") + self.assertEqual(fetched.author, "Charlie") + session.close() + + def test_set_ordinal_and_metadata_together(self): + session = self.Session() + c = self.tsdb.get_or_create_commit(session, "uc-both-1") + self.tsdb.update_commit(session, c, ordinal=300, author="Dave") + session.commit() + + fetched = self.tsdb.get_commit(session, commit="uc-both-1") + self.assertEqual(fetched.ordinal, 300) + self.assertEqual(fetched.author, "Dave") + session.close() + + def test_unknown_metadata_ignored(self): + """update_commit ignores keywords that are not in commit_fields.""" + session = self.Session() + c = self.tsdb.get_or_create_commit(session, "uc-ignore-1") + # Should not raise + self.tsdb.update_commit(session, c, nonexistent_field="value") + session.commit() + session.close() + + +class TestFieldChangeCRUD(unittest.TestCase): + + @classmethod + def setUpClass(cls): + cls.engine = _make_engine() + cls.schema = _test_schema() + cls.suite_models = create_suite_models(cls.schema) + cls.suite_models.base.metadata.drop_all(cls.engine) + cls.suite_models.base.metadata.create_all(cls.engine) + cls.Session = sqlalchemy.orm.sessionmaker(cls.engine) + + class _FakeV5DB: + pass + cls.tsdb = V5TestSuiteDB(_FakeV5DB(), cls.schema, cls.suite_models) + + @classmethod + def tearDownClass(cls): + cls.suite_models.base.metadata.drop_all(cls.engine) + cls.engine.dispose() + + def test_field_change_crud(self): + session = self.Session() + machine = self.tsdb.get_or_create_machine(session, "fc-crud-m") + test = self.tsdb.get_or_create_test(session, "fc-crud-test") + c1 = self.tsdb.get_or_create_commit(session, "fc-crud-c1") + c2 = self.tsdb.get_or_create_commit(session, "fc-crud-c2") + + fc = self.tsdb.create_field_change( + session, machine, test, "execution_time", c1, c2, 1.0, 2.0) + session.commit() + + # Fetch by uuid + fetched = self.tsdb.get_field_change(session, uuid=fc.uuid) + self.assertIsNotNone(fetched) + self.assertEqual(fetched.field_name, "execution_time") + self.assertEqual(fetched.old_value, 1.0) + self.assertEqual(fetched.new_value, 2.0) + + # List + all_fcs = self.tsdb.list_field_changes(session, machine=machine) + self.assertGreater(len(all_fcs), 0) + session.close() + + def test_regression_crud(self): + session = self.Session() + machine = self.tsdb.get_or_create_machine(session, "reg-crud-m") + test = self.tsdb.get_or_create_test(session, "reg-crud-test") + c1 = self.tsdb.get_or_create_commit(session, "reg-crud-c1") + c2 = self.tsdb.get_or_create_commit(session, "reg-crud-c2") + fc = self.tsdb.create_field_change( + session, machine, test, "execution_time", c1, c2, 1.0, 3.0) + session.flush() + + reg = self.tsdb.create_regression( + session, "Perf regression", [fc.id], bug="BUG-123", state=0) + session.commit() + self.assertIsNotNone(reg.uuid) + + # Update + self.tsdb.update_regression( + session, reg, title="Updated title", state=1) + session.commit() + fetched = self.tsdb.get_regression(session, uuid=reg.uuid) + self.assertEqual(fetched.title, "Updated title") + self.assertEqual(fetched.state, 1) + + # List + all_regs = self.tsdb.list_regressions(session) + self.assertGreater(len(all_regs), 0) + + # Delete + reg_id = reg.id + self.tsdb.delete_regression(session, reg_id) + session.commit() + self.assertIsNone(self.tsdb.get_regression(session, id=reg_id)) + session.close() + + def test_regression_with_empty_field_change_ids(self): + session = self.Session() + reg = self.tsdb.create_regression( + session, "Empty regression", [], state=0) + session.commit() + + self.assertIsNotNone(reg.id) + self.assertIsNotNone(reg.uuid) + + # Verify no indicators were created + indicators = ( + session.query(self.tsdb.RegressionIndicator) + .filter_by(regression_id=reg.id) + .all() + ) + self.assertEqual(len(indicators), 0) + + # Cleanup + self.tsdb.delete_regression(session, reg.id) + session.commit() + session.close() + + +class TestDeleteCommit(unittest.TestCase): + """Deletion cascades to runs/samples but is blocked by FieldChanges.""" + + @classmethod + def setUpClass(cls): + cls.engine = _make_engine() + cls.schema = _test_schema() + cls.suite_models = create_suite_models(cls.schema) + cls.suite_models.base.metadata.drop_all(cls.engine) + cls.suite_models.base.metadata.create_all(cls.engine) + cls.Session = sqlalchemy.orm.sessionmaker(cls.engine) + + class _FakeV5DB: + pass + cls.tsdb = V5TestSuiteDB(_FakeV5DB(), cls.schema, cls.suite_models) + + @classmethod + def tearDownClass(cls): + cls.suite_models.base.metadata.drop_all(cls.engine) + cls.engine.dispose() + + def test_delete_commit_cascades_to_runs_and_samples(self): + session = self.Session() + machine = self.tsdb.get_or_create_machine(session, "del-commit-m") + commit = self.tsdb.get_or_create_commit(session, "del-commit-c1") + test = self.tsdb.get_or_create_test(session, "del-commit-test") + run = self.tsdb.create_run( + session, machine, commit=commit) + self.tsdb.create_samples(session, run, [{ + "test_id": test.id, + "execution_time": 1.0, + }]) + session.flush() + + commit_id = commit.id + run_id = run.id + + self.tsdb.delete_commit(session, commit_id) + session.commit() + + # Commit, run, and samples are gone + self.assertIsNone( + session.query(self.tsdb.Commit).get(commit_id)) + self.assertIsNone( + session.query(self.tsdb.Run).get(run_id)) + samples = ( + session.query(self.tsdb.Sample) + .filter_by(run_id=run_id) + .all() + ) + self.assertEqual(len(samples), 0) + session.close() + + def test_delete_commit_blocked_by_field_changes(self): + """Cannot delete a commit referenced by FieldChanges.""" + session = self.Session() + machine = self.tsdb.get_or_create_machine(session, "del-commit-m2") + test = self.tsdb.get_or_create_test(session, "del-commit-test2") + c1 = self.tsdb.get_or_create_commit(session, "del-commit-fc-c1") + c2 = self.tsdb.get_or_create_commit(session, "del-commit-fc-c2") + + self.tsdb.create_field_change( + session, machine, test, "execution_time", c1, c2, 1.0, 2.0) + session.flush() + + # Cannot delete c1 (start_commit_id) + with self.assertRaises(ValueError): + self.tsdb.delete_commit(session, c1.id) + + # Cannot delete c2 (end_commit_id) + with self.assertRaises(ValueError): + self.tsdb.delete_commit(session, c2.id) + + session.close() + + def test_delete_nonexistent_commit(self): + session = self.Session() + self.tsdb.delete_commit(session, 999999) + session.close() + + +class TestGetAndListTests(_CRUDTestBase): + + def test_get_test_by_name(self): + session = self.Session() + self.tsdb.get_or_create_test(session, "get-test-1") + session.commit() + + fetched = self.tsdb.get_test(session, name="get-test-1") + self.assertIsNotNone(fetched) + self.assertEqual(fetched.name, "get-test-1") + session.close() + + def test_get_test_by_id(self): + session = self.Session() + t = self.tsdb.get_or_create_test(session, "get-test-2") + session.commit() + + fetched = self.tsdb.get_test(session, id=t.id) + self.assertIsNotNone(fetched) + self.assertEqual(fetched.name, "get-test-2") + session.close() + + def test_get_test_not_found(self): + session = self.Session() + self.assertIsNone(self.tsdb.get_test(session, name="nonexistent")) + session.close() + + def test_get_test_no_args_raises(self): + session = self.Session() + with self.assertRaises(ValueError): + self.tsdb.get_test(session) + session.close() + + def test_list_tests(self): + session = self.Session() + self.tsdb.get_or_create_test(session, "list-test-a") + self.tsdb.get_or_create_test(session, "list-test-b") + session.commit() + + results = self.tsdb.list_tests(session) + names = [t.name for t in results] + self.assertIn("list-test-a", names) + self.assertIn("list-test-b", names) + session.close() + + def test_list_tests_with_search(self): + session = self.Session() + self.tsdb.get_or_create_test(session, "search-test-alpha") + self.tsdb.get_or_create_test(session, "search-test-beta") + self.tsdb.get_or_create_test(session, "other-test") + session.commit() + + results = self.tsdb.list_tests(session, search="search-test") + names = [t.name for t in results] + self.assertIn("search-test-alpha", names) + self.assertIn("search-test-beta", names) + self.assertNotIn("other-test", names) + session.close() + + def test_list_tests_with_limit(self): + session = self.Session() + results = self.tsdb.list_tests(session, limit=1) + self.assertLessEqual(len(results), 1) + session.close() + + +class TestListSamples(_CRUDTestBase): + + def test_list_samples_by_run(self): + session = self.Session() + machine = self.tsdb.get_or_create_machine(session, "ls-m") + commit = self.tsdb.get_or_create_commit(session, "ls-c") + test = self.tsdb.get_or_create_test(session, "ls-test") + run = self.tsdb.create_run(session, machine, commit=commit) + self.tsdb.create_samples(session, run, [ + {"test_id": test.id, "execution_time": 1.0}, + ]) + session.commit() + + results = self.tsdb.list_samples(session, run_id=run.id) + self.assertEqual(len(results), 1) + self.assertAlmostEqual(results[0].execution_time, 1.0) + session.close() + + def test_list_samples_by_test(self): + session = self.Session() + machine = self.tsdb.get_or_create_machine(session, "ls-m2") + commit = self.tsdb.get_or_create_commit(session, "ls-c2") + test_a = self.tsdb.get_or_create_test(session, "ls-test-a") + test_b = self.tsdb.get_or_create_test(session, "ls-test-b") + run = self.tsdb.create_run(session, machine, commit=commit) + self.tsdb.create_samples(session, run, [ + {"test_id": test_a.id, "execution_time": 1.0}, + {"test_id": test_b.id, "execution_time": 2.0}, + ]) + session.commit() + + results = self.tsdb.list_samples(session, test_id=test_a.id) + test_ids = [s.test_id for s in results] + self.assertTrue(all(tid == test_a.id for tid in test_ids)) + session.close() + + def test_list_samples_empty(self): + session = self.Session() + results = self.tsdb.list_samples(session, run_id=999999) + self.assertEqual(len(results), 0) + session.close() + + +class TestUpdateMachine(_CRUDTestBase): + + def test_update_machine_name(self): + session = self.Session() + m = self.tsdb.get_or_create_machine(session, "upd-m-1") + session.commit() + + self.tsdb.update_machine(session, m, name="upd-m-1-renamed") + session.commit() + + self.assertEqual(m.name, "upd-m-1-renamed") + fetched = self.tsdb.get_machine(session, name="upd-m-1-renamed") + self.assertIsNotNone(fetched) + session.close() + + def test_update_machine_fields(self): + session = self.Session() + m = self.tsdb.get_or_create_machine(session, "upd-m-2", hardware="x86") + session.commit() + self.assertEqual(m.hardware, "x86") + + self.tsdb.update_machine(session, m, hardware="arm64") + session.commit() + + fetched = self.tsdb.get_machine(session, name="upd-m-2") + self.assertEqual(fetched.hardware, "arm64") + session.close() + + def test_update_machine_parameters(self): + session = self.Session() + m = self.tsdb.get_or_create_machine( + session, "upd-m-3", parameters={"old": "value"}) + session.commit() + + self.tsdb.update_machine( + session, m, parameters={"new": "value"}) + session.commit() + + fetched = self.tsdb.get_machine(session, name="upd-m-3") + self.assertEqual(fetched.parameters, {"new": "value"}) + session.close() + + def test_update_machine_ignores_unknown_fields(self): + session = self.Session() + m = self.tsdb.get_or_create_machine(session, "upd-m-4") + session.commit() + + # Should not raise + self.tsdb.update_machine(session, m, nonexistent_field="value") + session.commit() + session.close() + + +class TestDeleteFieldChange(_CRUDTestBase): + + def test_delete_field_change(self): + session = self.Session() + machine = self.tsdb.get_or_create_machine(session, "dfc-m") + test = self.tsdb.get_or_create_test(session, "dfc-test") + c1 = self.tsdb.get_or_create_commit(session, "dfc-c1") + c2 = self.tsdb.get_or_create_commit(session, "dfc-c2") + fc = self.tsdb.create_field_change( + session, machine, test, "execution_time", c1, c2, 1.0, 2.0) + session.commit() + fc_id = fc.id + + self.tsdb.delete_field_change(session, fc_id) + session.commit() + + self.assertIsNone(self.tsdb.get_field_change(session, id=fc_id)) + session.close() + + def test_delete_field_change_cascades_to_indicators(self): + session = self.Session() + machine = self.tsdb.get_or_create_machine(session, "dfc-m2") + test = self.tsdb.get_or_create_test(session, "dfc-test2") + c1 = self.tsdb.get_or_create_commit(session, "dfc-c3") + c2 = self.tsdb.get_or_create_commit(session, "dfc-c4") + fc = self.tsdb.create_field_change( + session, machine, test, "execution_time", c1, c2, 1.0, 2.0) + reg = self.tsdb.create_regression( + session, "test reg", [fc.id], state=0) + session.commit() + + fc_id = fc.id + reg_id = reg.id + + # Delete field change -- should also remove the indicator + self.tsdb.delete_field_change(session, fc_id) + session.commit() + + indicators = ( + session.query(self.tsdb.RegressionIndicator) + .filter_by(regression_id=reg_id) + .all() + ) + self.assertEqual(len(indicators), 0) + session.close() + + def test_delete_nonexistent_field_change(self): + session = self.Session() + # Should not raise + self.tsdb.delete_field_change(session, 999999) + session.close() + + +class TestRegressionIndicatorManagement(_CRUDTestBase): + + def _make_fc(self, session, suffix=""): + machine = self.tsdb.get_or_create_machine(session, f"ri-m{suffix}") + test = self.tsdb.get_or_create_test(session, f"ri-test{suffix}") + c1 = self.tsdb.get_or_create_commit(session, f"ri-c1{suffix}") + c2 = self.tsdb.get_or_create_commit(session, f"ri-c2{suffix}") + return self.tsdb.create_field_change( + session, machine, test, "execution_time", c1, c2, 1.0, 2.0) + + def test_add_regression_indicator(self): + session = self.Session() + fc = self._make_fc(session, "-add") + reg = self.tsdb.create_regression(session, "add-ind", [], state=0) + session.flush() + + ri = self.tsdb.add_regression_indicator(session, reg, fc) + session.commit() + + self.assertIsNotNone(ri.id) + indicators = ( + session.query(self.tsdb.RegressionIndicator) + .filter_by(regression_id=reg.id) + .all() + ) + self.assertEqual(len(indicators), 1) + session.close() + + def test_add_duplicate_indicator_rejected(self): + session = self.Session() + fc = self._make_fc(session, "-dup") + reg = self.tsdb.create_regression(session, "dup-ind", [fc.id], state=0) + session.commit() + + # Adding the same indicator again should fail + with self.assertRaises(sqlalchemy.exc.IntegrityError): + self.tsdb.add_regression_indicator(session, reg, fc) + session.rollback() + session.close() + + def test_remove_regression_indicator(self): + session = self.Session() + fc = self._make_fc(session, "-rem") + reg = self.tsdb.create_regression(session, "rem-ind", [fc.id], state=0) + session.commit() + + removed = self.tsdb.remove_regression_indicator( + session, reg.id, fc.id) + session.commit() + self.assertTrue(removed) + + indicators = ( + session.query(self.tsdb.RegressionIndicator) + .filter_by(regression_id=reg.id) + .all() + ) + self.assertEqual(len(indicators), 0) + session.close() + + def test_remove_nonexistent_indicator(self): + session = self.Session() + removed = self.tsdb.remove_regression_indicator(session, 999, 999) + self.assertFalse(removed) + session.close() + + +class TestRegressionStateValidation(_CRUDTestBase): + + def test_create_with_invalid_state(self): + session = self.Session() + with self.assertRaises(ValueError): + self.tsdb.create_regression(session, "bad state", [], state=99) + session.close() + + def test_update_with_invalid_state(self): + session = self.Session() + reg = self.tsdb.create_regression( + session, "valid", [], state=0) + session.commit() + + with self.assertRaises(ValueError): + self.tsdb.update_regression(session, reg, state=-1) + session.close() + + def test_all_valid_states_accepted(self): + session = self.Session() + for state_val in sorted(VALID_REGRESSION_STATES): + reg = self.tsdb.create_regression( + session, f"state-{state_val}", [], state=state_val) + self.assertEqual(reg.state, state_val) + session.commit() + session.close() + + +if __name__ == '__main__': + unittest.main(argv=[sys.argv[0]], exit=True) diff --git a/tests/server/db/v5/test_import.py b/tests/server/db/v5/test_import.py new file mode 100644 index 000000000..058f331d7 --- /dev/null +++ b/tests/server/db/v5/test_import.py @@ -0,0 +1,734 @@ +# RUN: rm -rf %t.instance %t.pg.log +# RUN: %{utils}/with_postgres.sh %t.pg.log \ +# RUN: python %s +# END. + +import os +import sys +import unittest + +import json + +import sqlalchemy +import sqlalchemy.orm + +from lnt.server.db.v5.schema import parse_schema +from lnt.server.db.v5.models import ( + V5Schema, + V5SchemaVersion, + create_global_tables, + create_suite_models, +) +from lnt.server.db.v5 import V5DB, V5TestSuiteDB + + +def _make_engine(): + db_uri = os.environ.get('LNT_TEST_DB_URI') + db_name = os.environ.get('LNT_TEST_DB_NAME') + if not db_uri or not db_name: + raise unittest.SkipTest( + "LNT_TEST_DB_URI / LNT_TEST_DB_NAME not set") + return sqlalchemy.create_engine(f"{db_uri}/{db_name}") + + +def _test_schema(): + return parse_schema({ + "name": "imp", + "metrics": [ + {"name": "compile_time", "type": "real"}, + {"name": "execution_time", "type": "real"}, + ], + "commit_fields": [ + {"name": "git_sha", "searchable": True}, + {"name": "author", "searchable": True}, + ], + "machine_fields": [ + {"name": "hardware", "searchable": True}, + {"name": "os", "searchable": True}, + ], + }) + + +class _ImportTestBase(unittest.TestCase): + + @classmethod + def setUpClass(cls): + cls.engine = _make_engine() + cls.schema = _test_schema() + cls.suite_models = create_suite_models(cls.schema) + cls.suite_models.base.metadata.drop_all(cls.engine) + cls.suite_models.base.metadata.create_all(cls.engine) + cls.Session = sqlalchemy.orm.sessionmaker(cls.engine) + + # Build a lightweight V5TestSuiteDB (we don't need the full V5DB) + class _FakeV5DB: + pass + cls.tsdb = V5TestSuiteDB(_FakeV5DB(), cls.schema, cls.suite_models) + + @classmethod + def tearDownClass(cls): + cls.suite_models.base.metadata.drop_all(cls.engine) + cls.engine.dispose() + + +class TestImportRun(_ImportTestBase): + + def test_import_with_commit(self): + session = self.Session() + data = { + "format_version": "5", + "machine": { + "name": "import-machine-1", + "hardware": "x86_64", + "os": "linux", + }, + "commit": "abc123", + "commit_fields": { + "git_sha": "abc123def456789", + "author": "Jane Doe", + }, + "run_parameters": { + "build_config": "Release", + }, + "tests": [ + { + "name": "test.suite/benchmark1", + "compile_time": 1.23, + "execution_time": 0.45, + }, + { + "name": "test.suite/benchmark2", + "execution_time": 0.67, + }, + ], + } + run = self.tsdb.import_run(session, data) + session.commit() + + self.assertIsNotNone(run.id) + self.assertIsNotNone(run.uuid) + self.assertIsNotNone(run.commit_id) + self.assertEqual(run.run_parameters, {"build_config": "Release"}) + + # Verify commit was created + commit = self.tsdb.get_commit(session, id=run.commit_id) + self.assertEqual(commit.commit, "abc123") + self.assertEqual(commit.git_sha, "abc123def456789") + self.assertEqual(commit.author, "Jane Doe") + self.assertIsNone(commit.ordinal) + + # Verify machine + machine = self.tsdb.get_machine(session, id=run.machine_id) + self.assertEqual(machine.name, "import-machine-1") + self.assertEqual(machine.hardware, "x86_64") + self.assertEqual(machine.os, "linux") + + # Verify samples + samples = ( + session.query(self.suite_models.Sample) + .filter_by(run_id=run.id) + .all() + ) + self.assertEqual(len(samples), 2) + session.close() + + def test_import_without_commit(self): + session = self.Session() + data = { + "format_version": "5", + "machine": {"name": "import-machine-2"}, + "tests": [ + {"name": "test.suite/standalone", "execution_time": 0.1}, + ], + } + with self.assertRaises(ValueError): + self.tsdb.import_run(session, data) + session.rollback() + session.close() + + def test_import_missing_format_version(self): + """format_version is required -- omitting it must raise.""" + session = self.Session() + data = { + "machine": {"name": "import-machine-no-fmt"}, + "commit": "no-fmt-commit", + "tests": [{"name": "test/fmt", "execution_time": 1.0}], + } + with self.assertRaises(ValueError): + self.tsdb.import_run(session, data) + session.rollback() + session.close() + + def test_import_wrong_format_version(self): + """format_version must be '5' -- anything else must raise.""" + session = self.Session() + data = { + "format_version": "4", + "machine": {"name": "import-machine-wrong-fmt"}, + "commit": "wrong-fmt-commit", + "tests": [{"name": "test/fmt2", "execution_time": 1.0}], + } + with self.assertRaises(ValueError): + self.tsdb.import_run(session, data) + session.rollback() + session.close() + + def test_import_same_commit_twice(self): + """Second import at same commit should reuse the commit (first-write-wins).""" + session = self.Session() + data1 = { + "format_version": "5", + "machine": {"name": "import-machine-3"}, + "commit": "same-commit", + "commit_fields": {"author": "First"}, + "tests": [{"name": "test/a", "compile_time": 1.0}], + } + run1 = self.tsdb.import_run(session, data1) + session.commit() + + data2 = { + "format_version": "5", + "machine": {"name": "import-machine-3"}, + "commit": "same-commit", + "commit_fields": {"author": "Second"}, + "tests": [{"name": "test/a", "compile_time": 2.0}], + } + run2 = self.tsdb.import_run(session, data2) + session.commit() + + # Same commit reused + self.assertEqual(run1.commit_id, run2.commit_id) + + # First-write-wins: author should still be "First" + commit = self.tsdb.get_commit(session, id=run1.commit_id) + self.assertEqual(commit.author, "First") + session.close() + + def test_import_missing_machine_name(self): + session = self.Session() + data = { + "format_version": "5", + "machine": {}, + "tests": [{"name": "test/x", "compile_time": 1.0}], + } + with self.assertRaises(ValueError): + self.tsdb.import_run(session, data) + session.rollback() + session.close() + + def test_import_missing_test_name(self): + session = self.Session() + data = { + "format_version": "5", + "machine": {"name": "import-machine-4"}, + "commit": "missing-test-name-commit", + "tests": [{"compile_time": 1.0}], + } + with self.assertRaises(ValueError): + self.tsdb.import_run(session, data) + session.rollback() + session.close() + + def test_import_machine_extra_params(self): + """Extra machine keys not in schema go into parameters JSONB.""" + session = self.Session() + data = { + "format_version": "5", + "machine": { + "name": "import-machine-5", + "hardware": "arm64", + "extra_key": "extra_value", + }, + "commit": "extra-params-commit", + "tests": [{"name": "test/extra", "compile_time": 1.0}], + } + run = self.tsdb.import_run(session, data) + session.commit() + + machine = self.tsdb.get_machine(session, id=run.machine_id) + self.assertEqual(machine.hardware, "arm64") + self.assertEqual(machine.parameters.get("extra_key"), "extra_value") + session.close() + + def test_import_empty_tests_list(self): + session = self.Session() + data = { + "format_version": "5", + "machine": {"name": "import-machine-empty-tests"}, + "commit": "empty-tests-commit", + "tests": [], + } + run = self.tsdb.import_run(session, data) + session.commit() + + self.assertIsNotNone(run.id) + samples = ( + session.query(self.suite_models.Sample) + .filter_by(run_id=run.id) + .all() + ) + self.assertEqual(len(samples), 0) + session.close() + + def test_import_unknown_top_level_keys_ignored(self): + session = self.Session() + data = { + "format_version": "5", + "machine": {"name": "import-machine-unk-keys"}, + "commit": "unknown-keys-commit", + "tests": [{"name": "test/unk", "compile_time": 1.0}], + "unknown_key": "should be ignored", + "another_unknown": 42, + } + run = self.tsdb.import_run(session, data) + session.commit() + + self.assertIsNotNone(run.id) + session.close() + + def test_import_array_metric_creates_multiple_samples(self): + """Array metric values unpack into multiple Sample rows.""" + session = self.Session() + data = { + "format_version": "5", + "machine": {"name": "array-machine"}, + "commit": "array-commit", + "tests": [{ + "name": "test/array", + "compile_time": [1.0, 2.0, 3.0], + "execution_time": [0.1, 0.2, 0.3], + }], + } + run = self.tsdb.import_run(session, data) + session.commit() + + samples = self.tsdb.list_samples(session, run_id=run.id) + self.assertEqual(len(samples), 3) + compile_times = sorted(s.compile_time for s in samples) + exec_times = sorted(s.execution_time for s in samples) + self.assertEqual(compile_times, [1.0, 2.0, 3.0]) + self.assertEqual(exec_times, [0.1, 0.2, 0.3]) + session.close() + + def test_import_mixed_scalar_and_array_metrics(self): + """Scalar metrics are repeated across array-expanded samples.""" + session = self.Session() + data = { + "format_version": "5", + "machine": {"name": "mixed-machine"}, + "commit": "mixed-commit", + "tests": [{ + "name": "test/mixed", + "execution_time": [1.0, 2.0], + "compile_time": 0.5, + }], + } + run = self.tsdb.import_run(session, data) + session.commit() + + samples = self.tsdb.list_samples(session, run_id=run.id) + self.assertEqual(len(samples), 2) + for s in samples: + self.assertEqual(s.compile_time, 0.5) + exec_times = sorted(s.execution_time for s in samples) + self.assertEqual(exec_times, [1.0, 2.0]) + session.close() + + def test_import_array_inconsistent_lengths_rejected(self): + """Array metrics with different lengths raise ValueError.""" + session = self.Session() + data = { + "format_version": "5", + "machine": {"name": "incon-machine"}, + "commit": "incon-commit", + "tests": [{ + "name": "test/incon", + "execution_time": [1.0, 2.0], + "compile_time": [1.0, 2.0, 3.0], + }], + } + with self.assertRaises(ValueError): + self.tsdb.import_run(session, data) + session.rollback() + session.close() + + def test_import_empty_array_rejected(self): + """Empty metric arrays raise ValueError.""" + session = self.Session() + data = { + "format_version": "5", + "machine": {"name": "empty-arr-machine"}, + "commit": "empty-arr-commit", + "tests": [{ + "name": "test/empty-arr", + "execution_time": [], + }], + } + with self.assertRaises(ValueError): + self.tsdb.import_run(session, data) + session.rollback() + session.close() + + +class TestGetOrCreateCommit(_ImportTestBase): + + def test_empty_commit_string_rejected(self): + session = self.Session() + with self.assertRaises(ValueError): + self.tsdb.get_or_create_commit(session, "") + session.close() + + def test_long_commit_string(self): + session = self.Session() + long_str = "a" * 256 + c = self.tsdb.get_or_create_commit(session, long_str) + session.commit() + self.assertEqual(c.commit, long_str) + session.close() + + def test_special_chars_in_commit(self): + session = self.Session() + for s in ["with/slash", "with%percent", "unicode-\u00e9\u00e8", "with spaces"]: + c = self.tsdb.get_or_create_commit(session, s) + session.commit() + self.assertEqual(c.commit, s) + session.close() + + +class TestSearchMethods(_ImportTestBase): + + @classmethod + def setUpClass(cls): + super().setUpClass() + session = cls.Session() + # Seed some data + cls.tsdb.get_or_create_commit(session, "abc-100", git_sha="sha-abc", author="Alice") + cls.tsdb.get_or_create_commit(session, "abc-200", git_sha="sha-abd", author="Bob") + cls.tsdb.get_or_create_commit(session, "xyz-100", git_sha="sha-xyz", author="Alice Smith") + cls.tsdb.get_or_create_machine(session, "x86-machine-1", hardware="x86_64", os="linux") + cls.tsdb.get_or_create_machine(session, "arm-machine-1", hardware="aarch64", os="darwin") + session.commit() + session.close() + + def test_search_commits_by_commit_string(self): + session = self.Session() + results = self.tsdb.list_commits(session, search="abc") + names = [c.commit for c in results] + self.assertIn("abc-100", names) + self.assertIn("abc-200", names) + self.assertNotIn("xyz-100", names) + session.close() + + def test_search_commits_by_searchable_field(self): + """Search should match across searchable commit_fields (author).""" + session = self.Session() + results = self.tsdb.list_commits(session, search="Alice") + names = [c.commit for c in results] + # "Alice" matches commit abc-100 (author=Alice) and xyz-100 (author=Alice Smith) + self.assertIn("abc-100", names) + self.assertIn("xyz-100", names) + session.close() + + def test_search_machines_by_name(self): + session = self.Session() + results = self.tsdb.list_machines(session, search="x86") + names = [m.name for m in results] + self.assertIn("x86-machine-1", names) + self.assertNotIn("arm-machine-1", names) + session.close() + + def test_search_machines_by_searchable_field(self): + """Search should match across searchable machine_fields (hardware).""" + session = self.Session() + results = self.tsdb.list_machines(session, search="aarch64") + names = [m.name for m in results] + self.assertIn("arm-machine-1", names) + session.close() + + def test_empty_search_returns_all(self): + session = self.Session() + all_commits = self.tsdb.list_commits(session) + searched = self.tsdb.list_commits(session, search=None) + self.assertEqual(len(all_commits), len(searched)) + session.close() + + def test_search_with_sql_special_percent(self): + """Search with '%' should be treated literally, not as a wildcard.""" + session = self.Session() + # Create a commit whose string literally starts with "100%" + self.tsdb.get_or_create_commit(session, "100%done") + self.tsdb.get_or_create_commit(session, "100_safe") + session.commit() + + # Search for "100%" should match "100%done" but NOT "100_safe" + results = self.tsdb.list_commits(session, search="100%") + names = [c.commit for c in results] + self.assertIn("100%done", names) + self.assertNotIn("100_safe", names) + session.close() + + def test_search_with_sql_special_underscore(self): + """Search with '_' should be treated literally, not as a single-char wildcard.""" + session = self.Session() + # "100_" should not match "100X" where X is any char + self.tsdb.get_or_create_commit(session, "100_safe") + session.commit() + + results = self.tsdb.list_commits(session, search="100_") + names = [c.commit for c in results] + self.assertIn("100_safe", names) + # Should not match "100%done" (starts with 100 but 4th char is %, not _) + self.assertNotIn("100%done", names) + session.close() + + def test_search_with_sql_special_backslash(self): + """Search with backslash should be treated literally.""" + session = self.Session() + self.tsdb.get_or_create_commit(session, "path\\to\\thing") + session.commit() + + results = self.tsdb.list_commits(session, search="path\\") + names = [c.commit for c in results] + self.assertIn("path\\to\\thing", names) + session.close() + + def test_machine_search_with_sql_special_chars(self): + """Machine search should also escape SQL special characters.""" + session = self.Session() + self.tsdb.get_or_create_machine(session, "machine_with%special") + session.commit() + + results = self.tsdb.list_machines(session, search="machine_with%") + names = [m.name for m in results] + self.assertIn("machine_with%special", names) + session.close() + + def test_default_limit_on_list_commits(self): + session = self.Session() + # We can't easily create 1001 commits in a test, but we can verify + # that passing no limit still returns results (implying a limit is set) + # and that an explicit limit overrides the default. + results = self.tsdb.list_commits(session, limit=2) + self.assertLessEqual(len(results), 2) + session.close() + + def test_default_limit_on_list_machines(self): + session = self.Session() + results = self.tsdb.list_machines(session, limit=1) + self.assertLessEqual(len(results), 1) + session.close() + + def test_default_limit_on_list_runs(self): + session = self.Session() + results = self.tsdb.list_runs(session, limit=1) + self.assertLessEqual(len(results), 1) + session.close() + + +class TestSchemaStorageInDB(unittest.TestCase): + + @classmethod + def setUpClass(cls): + cls.engine = _make_engine() + cls.Session = sqlalchemy.orm.sessionmaker(cls.engine) + # Create global tables + create_global_tables(cls.engine) + + @classmethod + def tearDownClass(cls): + # Clean up global tables + from lnt.server.db.v5.models import _global_base + _global_base.metadata.drop_all(cls.engine) + cls.engine.dispose() + + def setUp(self): + # Clean any existing schema rows + session = self.Session() + session.query(V5Schema).delete() + row = session.query(V5SchemaVersion).get(1) + if row: + row.version = 0 + else: + session.add(V5SchemaVersion(id=1, version=0)) + session.commit() + session.close() + + def _make_v5db(self): + """Create a V5DB wired to the test Postgres database.""" + db_uri = os.environ.get('LNT_TEST_DB_URI') + db_name = os.environ.get('LNT_TEST_DB_NAME') + path = f"{db_uri}/{db_name}" + + class _FakeConfig: + schemasDir = "/nonexistent" + return V5DB(path, _FakeConfig()) + + def test_create_suite(self): + v5db = self._make_v5db() + schema = parse_schema({ + "name": "create_test", + "metrics": [{"name": "time", "type": "real"}], + }) + session = v5db.make_session() + tsdb = v5db.create_suite(session, schema) + session.commit() + session.close() + + self.assertIsNotNone(tsdb) + self.assertEqual(tsdb.name, "create_test") + self.assertIn("create_test", v5db.testsuite) + + # Verify row in v5_schema + session = v5db.make_session() + row = session.query(V5Schema).get("create_test") + self.assertIsNotNone(row) + data = json.loads(row.schema_json) + self.assertEqual(data["name"], "create_test") + session.close() + + # Clean up + session = v5db.make_session() + v5db.delete_suite(session, "create_test") + session.commit() + session.close() + v5db.close() + + def test_get_suite(self): + v5db = self._make_v5db() + self.assertIsNone(v5db.get_suite("nonexistent")) + + schema = parse_schema({ + "name": "get_test", + "metrics": [{"name": "time", "type": "real"}], + }) + session = v5db.make_session() + v5db.create_suite(session, schema) + session.commit() + session.close() + + result = v5db.get_suite("get_test") + self.assertIsNotNone(result) + self.assertEqual(result.name, "get_test") + + # Clean up + session = v5db.make_session() + v5db.delete_suite(session, "get_test") + session.commit() + session.close() + v5db.close() + + def test_delete_suite(self): + v5db = self._make_v5db() + schema = parse_schema({ + "name": "del_test", + "metrics": [{"name": "time", "type": "real"}], + }) + session = v5db.make_session() + v5db.create_suite(session, schema) + session.commit() + session.close() + + self.assertIn("del_test", v5db.testsuite) + + session = v5db.make_session() + v5db.delete_suite(session, "del_test") + session.commit() + session.close() + + self.assertNotIn("del_test", v5db.testsuite) + self.assertIsNone(v5db.get_suite("del_test")) + + # Verify row gone from v5_schema + session = v5db.make_session() + row = session.query(V5Schema).get("del_test") + self.assertIsNone(row) + session.close() + v5db.close() + + def test_delete_nonexistent_suite_raises(self): + v5db = self._make_v5db() + session = v5db.make_session() + with self.assertRaises(ValueError): + v5db.delete_suite(session, "nonexistent") + session.close() + v5db.close() + + def test_create_duplicate_suite_raises(self): + v5db = self._make_v5db() + schema = parse_schema({ + "name": "dup_test", + "metrics": [{"name": "time", "type": "real"}], + }) + session = v5db.make_session() + v5db.create_suite(session, schema) + session.commit() + + with self.assertRaises(ValueError): + v5db.create_suite(session, schema) + session.close() + + # Clean up + session = v5db.make_session() + v5db.delete_suite(session, "dup_test") + session.commit() + session.close() + v5db.close() + + def test_schema_version_bumped(self): + """create_suite and delete_suite bump the version counter.""" + v5db = self._make_v5db() + session = v5db.make_session() + + ver_before = session.query(V5SchemaVersion).get(1).version + + schema = parse_schema({ + "name": "ver_test", + "metrics": [{"name": "time", "type": "real"}], + }) + v5db.create_suite(session, schema) + session.commit() + + ver_after_create = session.query(V5SchemaVersion).get(1).version + self.assertEqual(ver_after_create, ver_before + 1) + + v5db.delete_suite(session, "ver_test") + session.commit() + + ver_after_delete = session.query(V5SchemaVersion).get(1).version + self.assertEqual(ver_after_delete, ver_before + 2) + session.close() + v5db.close() + + def test_staleness_detection(self): + """A second V5DB instance detects stale cache and reloads.""" + v5db1 = self._make_v5db() + schema = parse_schema({ + "name": "stale_test", + "metrics": [{"name": "time", "type": "real"}], + }) + session = v5db1.make_session() + v5db1.create_suite(session, schema) + session.commit() + session.close() + + # Create a second V5DB instance (simulates another worker) + v5db2 = self._make_v5db() + # v5db2 should see the suite because it loaded from DB on init + self.assertIn("stale_test", v5db2.testsuite) + + # Clean up + session = v5db1.make_session() + v5db1.delete_suite(session, "stale_test") + session.commit() + session.close() + + # v5db2 should detect staleness on next get_suite call + result = v5db2.get_suite("stale_test") + self.assertIsNone(result) + + v5db1.close() + v5db2.close() + + +if __name__ == '__main__': + unittest.main(argv=[sys.argv[0]], exit=True) diff --git a/tests/server/db/v5/test_models.py b/tests/server/db/v5/test_models.py new file mode 100644 index 000000000..5b127d480 --- /dev/null +++ b/tests/server/db/v5/test_models.py @@ -0,0 +1,626 @@ +# RUN: rm -rf %t.instance %t.pg.log +# RUN: %{utils}/with_postgres.sh %t.pg.log \ +# RUN: python %s +# END. + +import datetime +import os +import sys +import unittest + +import sqlalchemy +import sqlalchemy.exc + +from lnt.server.db.v5.schema import parse_schema +from lnt.server.db.v5.models import create_suite_models + + +def _make_engine(): + db_uri = os.environ.get('LNT_TEST_DB_URI') + db_name = os.environ.get('LNT_TEST_DB_NAME') + if not db_uri or not db_name: + raise unittest.SkipTest( + "LNT_TEST_DB_URI / LNT_TEST_DB_NAME not set " + "(run via with_postgres.sh)") + return sqlalchemy.create_engine(f"{db_uri}/{db_name}") + + +def _test_schema(): + return parse_schema({ + "name": "t", + "metrics": [ + {"name": "compile_time", "type": "real"}, + {"name": "execution_time", "type": "real"}, + {"name": "compile_status", "type": "status"}, + ], + "commit_fields": [ + {"name": "git_sha", "searchable": True}, + {"name": "author", "searchable": True}, + {"name": "message", "type": "text"}, + ], + "machine_fields": [ + {"name": "hardware", "searchable": True}, + {"name": "os", "searchable": True}, + ], + }) + + +class TestModelCreation(unittest.TestCase): + + @classmethod + def setUpClass(cls): + cls.engine = _make_engine() + cls.schema = _test_schema() + cls.models = create_suite_models(cls.schema) + cls.models.base.metadata.create_all(cls.engine) + cls.Session = sqlalchemy.orm.sessionmaker(cls.engine) + + @classmethod + def tearDownClass(cls): + cls.models.base.metadata.drop_all(cls.engine) + cls.engine.dispose() + + def test_commit_table_exists(self): + insp = sqlalchemy.inspect(self.engine) + self.assertIn("t_Commit", insp.get_table_names()) + + def test_commit_has_dynamic_columns(self): + """Dynamic commit_fields should appear as columns.""" + insp = sqlalchemy.inspect(self.engine) + cols = {c['name'] for c in insp.get_columns("t_Commit")} + self.assertIn("git_sha", cols) + self.assertIn("author", cols) + self.assertIn("message", cols) + + def test_machine_table_has_parameters(self): + insp = sqlalchemy.inspect(self.engine) + cols = {c['name'] for c in insp.get_columns("t_Machine")} + self.assertIn("parameters", cols) + self.assertIn("hardware", cols) + self.assertIn("os", cols) + + def test_sample_table_has_metric_columns(self): + """Schema-defined metrics should appear as dynamic columns.""" + insp = sqlalchemy.inspect(self.engine) + cols = {c['name'] for c in insp.get_columns("t_Sample")} + self.assertIn("compile_time", cols) + self.assertIn("execution_time", cols) + self.assertIn("compile_status", cols) + + def test_all_tables_created(self): + """All 8 per-suite tables should exist.""" + insp = sqlalchemy.inspect(self.engine) + tables = set(insp.get_table_names()) + expected = { + "t_Commit", "t_Machine", "t_Run", "t_Test", + "t_Sample", "t_FieldChange", "t_Regression", + "t_RegressionIndicator", + } + self.assertTrue(expected.issubset(tables), f"Missing: {expected - tables}") + + +class TestCommitCRUD(unittest.TestCase): + + @classmethod + def setUpClass(cls): + cls.engine = _make_engine() + cls.schema = _test_schema() + cls.models = create_suite_models(cls.schema) + cls.models.base.metadata.drop_all(cls.engine) + cls.models.base.metadata.create_all(cls.engine) + cls.Session = sqlalchemy.orm.sessionmaker(cls.engine) + + @classmethod + def tearDownClass(cls): + cls.models.base.metadata.drop_all(cls.engine) + cls.engine.dispose() + + def test_create_commit(self): + session = self.Session() + c = self.models.Commit() + c.commit = "abc123" + c.git_sha = "abc123def456" + c.author = "Jane" + session.add(c) + session.commit() + self.assertIsNotNone(c.id) + self.assertIsNone(c.ordinal) # ordinal always NULL on creation + session.close() + + def test_unique_commit_string(self): + """Duplicate commit strings should raise IntegrityError.""" + session = self.Session() + c1 = self.models.Commit() + c1.commit = "unique_test_1" + session.add(c1) + session.commit() + + c2 = self.models.Commit() + c2.commit = "unique_test_1" + session.add(c2) + with self.assertRaises(sqlalchemy.exc.IntegrityError): + session.commit() + session.rollback() + session.close() + + def test_ordinal_unique(self): + session = self.Session() + c1 = self.models.Commit() + c1.commit = "ord_test_1" + c1.ordinal = 42 + session.add(c1) + session.commit() + + c2 = self.models.Commit() + c2.commit = "ord_test_2" + c2.ordinal = 42 + session.add(c2) + with self.assertRaises(sqlalchemy.exc.IntegrityError): + session.commit() + session.rollback() + session.close() + + def test_ordinal_nullable(self): + """Ordinal can be NULL (multiple commits with NULL ordinal OK).""" + session = self.Session() + for i in range(3): + c = self.models.Commit() + c.commit = f"null_ord_{i}" + session.add(c) + session.commit() + + nulls = ( + session.query(self.models.Commit) + .filter(self.models.Commit.commit.like("null_ord_%")) + .all() + ) + self.assertEqual(len(nulls), 3) + for c in nulls: + self.assertIsNone(c.ordinal) + session.close() + + +class TestMachineCRUD(unittest.TestCase): + + @classmethod + def setUpClass(cls): + cls.engine = _make_engine() + cls.schema = _test_schema() + cls.models = create_suite_models(cls.schema) + cls.models.base.metadata.drop_all(cls.engine) + cls.models.base.metadata.create_all(cls.engine) + cls.Session = sqlalchemy.orm.sessionmaker(cls.engine) + + @classmethod + def tearDownClass(cls): + cls.models.base.metadata.drop_all(cls.engine) + cls.engine.dispose() + + def test_create_machine(self): + session = self.Session() + m = self.models.Machine() + m.name = "test-machine-1" + m.parameters = {"key": "value"} + m.hardware = "x86_64" + m.os = "linux" + session.add(m) + session.commit() + self.assertIsNotNone(m.id) + session.close() + + def test_machine_name_unique(self): + session = self.Session() + m1 = self.models.Machine() + m1.name = "unique-machine" + m1.parameters = {} + session.add(m1) + session.commit() + + m2 = self.models.Machine() + m2.name = "unique-machine" + m2.parameters = {} + session.add(m2) + with self.assertRaises(sqlalchemy.exc.IntegrityError): + session.commit() + session.rollback() + session.close() + + def test_parameters_default_empty(self): + """Machine parameters should default to empty dict on the server side.""" + session = self.Session() + m = self.models.Machine() + m.name = "default-params-machine" + session.add(m) + session.commit() + + fetched = session.query(self.models.Machine).filter_by( + name="default-params-machine").one() + self.assertEqual(fetched.parameters, {}) + session.close() + + def test_jsonb_nested_parameters(self): + session = self.Session() + m = self.models.Machine() + m.name = "nested-params-machine" + m.parameters = { + "config": {"threads": 4, "flags": ["-O2", "-march=native"]}, + "tags": ["ci", "nightly"], + } + session.add(m) + session.commit() + + fetched = session.query(self.models.Machine).filter_by( + name="nested-params-machine").one() + self.assertEqual(fetched.parameters["config"]["threads"], 4) + self.assertEqual(fetched.parameters["tags"], ["ci", "nightly"]) + session.close() + + +class TestRunCRUD(unittest.TestCase): + + @classmethod + def setUpClass(cls): + cls.engine = _make_engine() + cls.schema = _test_schema() + cls.models = create_suite_models(cls.schema) + cls.models.base.metadata.drop_all(cls.engine) + cls.models.base.metadata.create_all(cls.engine) + cls.Session = sqlalchemy.orm.sessionmaker(cls.engine) + + @classmethod + def tearDownClass(cls): + cls.models.base.metadata.drop_all(cls.engine) + cls.engine.dispose() + + def _make_machine(self, session, name="run-test-machine"): + m = self.models.Machine() + m.name = name + m.parameters = {} + session.add(m) + session.flush() + return m + + def _make_commit(self, session, commit_str="test-commit"): + c = self.models.Commit() + c.commit = commit_str + session.add(c) + session.flush() + return c + + def test_create_run_with_commit(self): + session = self.Session() + machine = self._make_machine(session, "run-m-1") + commit = self._make_commit(session, "run-c-1") + run = self.models.Run() + run.uuid = "aaaaaaaa-1111-2222-3333-444444444444" + run.machine_id = machine.id + run.commit_id = commit.id + run.submitted_at = datetime.datetime(2024, 1, 1, 12, 0, 0) + run.run_parameters = {"build": "Release"} + session.add(run) + session.commit() + self.assertIsNotNone(run.id) + self.assertEqual(run.commit_id, commit.id) + session.close() + + def test_create_run_without_commit_fails(self): + """Creating a run with NULL commit_id should raise IntegrityError.""" + session = self.Session() + machine = self._make_machine(session, "run-m-2") + run = self.models.Run() + run.uuid = "bbbbbbbb-1111-2222-3333-444444444444" + run.machine_id = machine.id + run.commit_id = None + run.submitted_at = datetime.datetime(2024, 1, 1, 12, 0, 0) + run.run_parameters = {} + session.add(run) + with self.assertRaises(sqlalchemy.exc.IntegrityError): + session.commit() + session.rollback() + session.close() + + def test_uuid_unique(self): + session = self.Session() + machine = self._make_machine(session, "run-m-3") + commit = self._make_commit(session, "run-c-3") + r1 = self.models.Run() + r1.uuid = "cccccccc-1111-2222-3333-444444444444" + r1.machine_id = machine.id + r1.commit_id = commit.id + r1.submitted_at = datetime.datetime.utcnow() + r1.run_parameters = {} + session.add(r1) + session.commit() + + r2 = self.models.Run() + r2.uuid = "cccccccc-1111-2222-3333-444444444444" # same + r2.machine_id = machine.id + r2.commit_id = commit.id + r2.submitted_at = datetime.datetime.utcnow() + r2.run_parameters = {} + session.add(r2) + with self.assertRaises(sqlalchemy.exc.IntegrityError): + session.commit() + session.rollback() + session.close() + + def test_run_parameters_jsonb(self): + session = self.Session() + machine = self._make_machine(session, "run-m-4") + commit = self._make_commit(session, "run-c-4") + run = self.models.Run() + run.uuid = "dddddddd-1111-2222-3333-444444444444" + run.machine_id = machine.id + run.commit_id = commit.id + run.submitted_at = datetime.datetime.utcnow() + run.run_parameters = { + "nested": {"key": [1, 2, 3]}, + "null_value": None, + } + session.add(run) + session.commit() + + fetched = session.query(self.models.Run).filter_by( + uuid="dddddddd-1111-2222-3333-444444444444").one() + self.assertEqual(fetched.run_parameters["nested"]["key"], [1, 2, 3]) + self.assertIsNone(fetched.run_parameters["null_value"]) + session.close() + + +class TestSampleCreation(unittest.TestCase): + + @classmethod + def setUpClass(cls): + cls.engine = _make_engine() + cls.schema = _test_schema() + cls.models = create_suite_models(cls.schema) + cls.models.base.metadata.drop_all(cls.engine) + cls.models.base.metadata.create_all(cls.engine) + cls.Session = sqlalchemy.orm.sessionmaker(cls.engine) + + @classmethod + def tearDownClass(cls): + cls.models.base.metadata.drop_all(cls.engine) + cls.engine.dispose() + + def test_create_sample_with_metrics(self): + session = self.Session() + + m = self.models.Machine() + m.name = "sample-machine" + m.parameters = {} + session.add(m) + session.flush() + + c = self.models.Commit() + c.commit = "sample-commit" + session.add(c) + session.flush() + + t = self.models.Test() + t.name = "test.suite/benchmark" + session.add(t) + session.flush() + + r = self.models.Run() + r.uuid = "sample-run-uuid-00000000000000000"[:36] + r.machine_id = m.id + r.commit_id = c.id + r.submitted_at = datetime.datetime.utcnow() + r.run_parameters = {} + session.add(r) + session.flush() + + s = self.models.Sample() + s.run_id = r.id + s.test_id = t.id + s.compile_time = 1.5 + s.execution_time = 0.3 + s.compile_status = 0 + session.add(s) + session.commit() + + fetched = session.query(self.models.Sample).filter_by(run_id=r.id).one() + self.assertAlmostEqual(fetched.compile_time, 1.5) + self.assertAlmostEqual(fetched.execution_time, 0.3) + self.assertEqual(fetched.compile_status, 0) + session.close() + + def test_test_name_unique(self): + session = self.Session() + t1 = self.models.Test() + t1.name = "unique-test" + session.add(t1) + session.commit() + + t2 = self.models.Test() + t2.name = "unique-test" + session.add(t2) + with self.assertRaises(sqlalchemy.exc.IntegrityError): + session.commit() + session.rollback() + session.close() + + +class TestFieldChangeAndRegression(unittest.TestCase): + + @classmethod + def setUpClass(cls): + cls.engine = _make_engine() + cls.schema = _test_schema() + cls.models = create_suite_models(cls.schema) + cls.models.base.metadata.drop_all(cls.engine) + cls.models.base.metadata.create_all(cls.engine) + cls.Session = sqlalchemy.orm.sessionmaker(cls.engine) + + @classmethod + def tearDownClass(cls): + cls.models.base.metadata.drop_all(cls.engine) + cls.engine.dispose() + + def _setup(self, session, suffix=""): + m = self.models.Machine() + m.name = f"fc-machine{suffix}" + m.parameters = {} + session.add(m) + + t = self.models.Test() + t.name = f"fc-test{suffix}" + session.add(t) + + c1 = self.models.Commit() + c1.commit = f"fc-start{suffix}" + session.add(c1) + + c2 = self.models.Commit() + c2.commit = f"fc-end{suffix}" + session.add(c2) + + session.flush() + return m, t, c1, c2 + + def test_create_field_change(self): + session = self.Session() + m, t, c1, c2 = self._setup(session, "-create") + + fc = self.models.FieldChange() + fc.uuid = "fc-uuid-0000000000000000000000000"[:36] + fc.machine_id = m.id + fc.test_id = t.id + fc.field_name = "compile_time" + fc.start_commit_id = c1.id + fc.end_commit_id = c2.id + fc.old_value = 1.0 + fc.new_value = 2.0 + session.add(fc) + session.commit() + self.assertIsNotNone(fc.id) + session.close() + + def test_regression_indicator_unique_constraint(self): + """Duplicate (regression_id, field_change_id) should fail.""" + session = self.Session() + m, t, c1, c2 = self._setup(session, "-uniq") + + fc = self.models.FieldChange() + fc.uuid = "fc-uuid-uniq00000000000000000000"[:36] + fc.machine_id = m.id + fc.test_id = t.id + fc.field_name = "execution_time" + fc.start_commit_id = c1.id + fc.end_commit_id = c2.id + fc.old_value = 1.0 + fc.new_value = 2.0 + session.add(fc) + session.flush() + + reg = self.models.Regression() + reg.uuid = "reg-uuid-uniq0000000000000000000"[:36] + reg.title = "Test Regression" + reg.state = 0 + session.add(reg) + session.flush() + + ri1 = self.models.RegressionIndicator() + ri1.regression_id = reg.id + ri1.field_change_id = fc.id + session.add(ri1) + session.flush() + + ri2 = self.models.RegressionIndicator() + ri2.regression_id = reg.id + ri2.field_change_id = fc.id + session.add(ri2) + with self.assertRaises(sqlalchemy.exc.IntegrityError): + session.flush() + session.rollback() + session.close() + + +class TestCascadingDeletes(unittest.TestCase): + + @classmethod + def setUpClass(cls): + cls.engine = _make_engine() + cls.schema = _test_schema() + cls.models = create_suite_models(cls.schema) + cls.models.base.metadata.drop_all(cls.engine) + cls.models.base.metadata.create_all(cls.engine) + cls.Session = sqlalchemy.orm.sessionmaker(cls.engine) + + @classmethod + def tearDownClass(cls): + cls.models.base.metadata.drop_all(cls.engine) + cls.engine.dispose() + + def test_delete_run_keeps_commit(self): + """Deleting a run should NOT delete the commit.""" + session = self.Session() + + m = self.models.Machine() + m.name = "cascade-machine" + m.parameters = {} + session.add(m) + + c = self.models.Commit() + c.commit = "cascade-commit" + session.add(c) + session.flush() + + r = self.models.Run() + r.uuid = "cascade-run-uuid00000000000000000"[:36] + r.machine_id = m.id + r.commit_id = c.id + r.submitted_at = datetime.datetime.utcnow() + r.run_parameters = {} + session.add(r) + session.flush() + + run_id = r.id + commit_id = c.id + + session.delete(r) + session.commit() + + # Run is gone + self.assertIsNone( + session.query(self.models.Run).get(run_id)) + # Commit survives + self.assertIsNotNone( + session.query(self.models.Commit).get(commit_id)) + session.close() + + def test_delete_machine_cascades_to_runs(self): + """Deleting a machine should cascade-delete its runs.""" + session = self.Session() + + m = self.models.Machine() + m.name = "cascade-machine-2" + m.parameters = {} + session.add(m) + + c = self.models.Commit() + c.commit = "cascade-machine-commit" + session.add(c) + session.flush() + + r = self.models.Run() + r.uuid = "cascade-m-run-uuid0000000000000000"[:36] + r.machine_id = m.id + r.commit_id = c.id + r.submitted_at = datetime.datetime.utcnow() + r.run_parameters = {} + session.add(r) + session.flush() + run_id = r.id + + session.delete(m) + session.commit() + + self.assertIsNone( + session.query(self.models.Run).get(run_id)) + session.close() + + +if __name__ == '__main__': + unittest.main(argv=[sys.argv[0]], exit=True) diff --git a/tests/server/db/v5/test_schema.py b/tests/server/db/v5/test_schema.py new file mode 100644 index 000000000..eca4fca4e --- /dev/null +++ b/tests/server/db/v5/test_schema.py @@ -0,0 +1,328 @@ +# RUN: python %s +# END. + +import sys +import unittest + +from lnt.server.db.v5.schema import ( + CommitField, + MachineField, + Metric, + SchemaError, + parse_schema, +) + + +class TestParseSchemaBasic(unittest.TestCase): + + def test_minimal_schema(self): + schema = parse_schema({"name": "minimal"}) + self.assertEqual(schema.name, "minimal") + self.assertEqual(schema.metrics, []) + self.assertEqual(schema.commit_fields, []) + self.assertEqual(schema.machine_fields, []) + + def test_full_schema(self): + data = { + "name": "nts", + "metrics": [ + {"name": "compile_time", "type": "Real", "display_name": "Compile Time", + "unit": "seconds", "unit_abbrev": "s"}, + {"name": "execution_time", "type": "real", "bigger_is_better": False}, + {"name": "compile_status", "type": "status"}, + {"name": "hash", "type": "Hash"}, + ], + "commit_fields": [ + {"name": "git_sha", "searchable": True}, + {"name": "author", "searchable": True}, + {"name": "commit_message", "type": "text"}, + {"name": "commit_timestamp", "type": "datetime"}, + {"name": "priority", "type": "integer"}, + ], + "machine_fields": [ + {"name": "hardware", "searchable": True}, + {"name": "os", "searchable": True}, + ], + } + schema = parse_schema(data) + self.assertEqual(schema.name, "nts") + + self.assertEqual(len(schema.metrics), 4) + self.assertEqual(schema.metrics[0].name, "compile_time") + self.assertEqual(schema.metrics[0].type, "real") + self.assertEqual(schema.metrics[0].display_name, "Compile Time") + self.assertEqual(schema.metrics[0].unit, "seconds") + self.assertEqual(schema.metrics[1].type, "real") + self.assertEqual(schema.metrics[2].type, "status") + self.assertEqual(schema.metrics[3].type, "hash") + + self.assertEqual(len(schema.commit_fields), 5) + self.assertTrue(schema.commit_fields[0].searchable) + self.assertEqual(schema.commit_fields[2].type, "text") + self.assertEqual(schema.commit_fields[3].type, "datetime") + self.assertEqual(schema.commit_fields[4].type, "integer") + + self.assertEqual(len(schema.machine_fields), 2) + self.assertTrue(schema.machine_fields[0].searchable) + + def test_searchable_commit_fields(self): + data = { + "name": "test", + "commit_fields": [ + {"name": "a", "searchable": True}, + {"name": "b", "searchable": False}, + {"name": "c"}, + ], + } + schema = parse_schema(data) + self.assertEqual(len(schema.searchable_commit_fields), 1) + self.assertEqual(schema.searchable_commit_fields[0].name, "a") + + def test_searchable_fields_cached(self): + """searchable_*_fields should return the same list object on repeated access.""" + data = { + "name": "test", + "commit_fields": [{"name": "a", "searchable": True}], + "machine_fields": [{"name": "hw", "searchable": True}], + } + schema = parse_schema(data) + self.assertIs(schema.searchable_commit_fields, schema.searchable_commit_fields) + self.assertIs(schema.searchable_machine_fields, schema.searchable_machine_fields) + + +class TestSchemaValidation(unittest.TestCase): + + def test_missing_name(self): + with self.assertRaises(SchemaError): + parse_schema({}) + + def test_empty_name(self): + with self.assertRaises(SchemaError): + parse_schema({"name": ""}) + + def test_reserved_commit_field_id(self): + data = { + "name": "test", + "commit_fields": [{"name": "id"}], + } + with self.assertRaises(SchemaError): + parse_schema(data) + + def test_reserved_commit_field_commit(self): + data = { + "name": "test", + "commit_fields": [{"name": "commit"}], + } + with self.assertRaises(SchemaError): + parse_schema(data) + + def test_reserved_commit_field_ordinal(self): + data = { + "name": "test", + "commit_fields": [{"name": "ordinal"}], + } + with self.assertRaises(SchemaError): + parse_schema(data) + + def test_reserved_machine_field_id(self): + data = { + "name": "test", + "machine_fields": [{"name": "id"}], + } + with self.assertRaises(SchemaError): + parse_schema(data) + + def test_reserved_machine_field_name(self): + data = { + "name": "test", + "machine_fields": [{"name": "name"}], + } + with self.assertRaises(SchemaError): + parse_schema(data) + + def test_reserved_machine_field_parameters(self): + data = { + "name": "test", + "machine_fields": [{"name": "parameters"}], + } + with self.assertRaises(SchemaError): + parse_schema(data) + + def test_unknown_commit_field_type(self): + data = { + "name": "test", + "commit_fields": [{"name": "foo", "type": "blob"}], + } + with self.assertRaises(SchemaError): + parse_schema(data) + + def test_unknown_metric_type(self): + data = { + "name": "test", + "metrics": [{"name": "foo", "type": "complex"}], + } + with self.assertRaises(SchemaError): + parse_schema(data) + + def test_duplicate_commit_field(self): + data = { + "name": "test", + "commit_fields": [{"name": "a"}, {"name": "a"}], + } + with self.assertRaises(SchemaError): + parse_schema(data) + + def test_duplicate_machine_field(self): + data = { + "name": "test", + "machine_fields": [{"name": "a"}, {"name": "a"}], + } + with self.assertRaises(SchemaError): + parse_schema(data) + + def test_duplicate_metric(self): + data = { + "name": "test", + "metrics": [{"name": "a"}, {"name": "a"}], + } + with self.assertRaises(SchemaError): + parse_schema(data) + + def test_commit_field_missing_name(self): + data = { + "name": "test", + "commit_fields": [{"type": "text"}], + } + with self.assertRaises(SchemaError): + parse_schema(data) + + def test_metric_missing_name(self): + data = { + "name": "test", + "metrics": [{"type": "real"}], + } + with self.assertRaises(SchemaError): + parse_schema(data) + + def test_default_commit_field_type(self): + """Omitting type on commit_field should default to 'default'.""" + data = { + "name": "test", + "commit_fields": [{"name": "foo"}], + } + schema = parse_schema(data) + self.assertEqual(schema.commit_fields[0].type, "default") + + def test_default_metric_type(self): + """Omitting type on metric should default to 'real'.""" + data = { + "name": "test", + "metrics": [{"name": "foo"}], + } + schema = parse_schema(data) + self.assertEqual(schema.metrics[0].type, "real") + + def test_bigger_is_better(self): + data = { + "name": "test", + "metrics": [{"name": "score", "type": "real", "bigger_is_better": True}], + } + schema = parse_schema(data) + self.assertTrue(schema.metrics[0].bigger_is_better) + + def test_reserved_metric_name_id(self): + """Metric named 'id' should be rejected (reserved Sample column).""" + data = { + "name": "test", + "metrics": [{"name": "id", "type": "real"}], + } + with self.assertRaises(SchemaError): + parse_schema(data) + + def test_reserved_metric_name_run_id(self): + """Metric named 'run_id' should be rejected (reserved Sample column).""" + data = { + "name": "test", + "metrics": [{"name": "run_id", "type": "real"}], + } + with self.assertRaises(SchemaError): + parse_schema(data) + + def test_reserved_metric_name_test_id(self): + """Metric named 'test_id' should be rejected (reserved Sample column).""" + data = { + "name": "test", + "metrics": [{"name": "test_id", "type": "real"}], + } + with self.assertRaises(SchemaError): + parse_schema(data) + + +class TestDisplayFlag(unittest.TestCase): + """Tests for the display:true commit_field validation (design D4).""" + + def test_single_display_true(self): + data = { + "name": "test", + "commit_fields": [ + {"name": "sha", "display": True}, + {"name": "author"}, + ], + } + schema = parse_schema(data) + self.assertTrue(schema.commit_fields[0].display) + self.assertFalse(schema.commit_fields[1].display) + + def test_no_display_true(self): + data = { + "name": "test", + "commit_fields": [ + {"name": "sha"}, + {"name": "author"}, + ], + } + schema = parse_schema(data) + self.assertFalse(schema.commit_fields[0].display) + self.assertFalse(schema.commit_fields[1].display) + + def test_multiple_display_true_rejected(self): + data = { + "name": "test", + "commit_fields": [ + {"name": "sha", "display": True}, + {"name": "label", "display": True}, + ], + } + with self.assertRaises(SchemaError): + parse_schema(data) + + def test_display_default_false(self): + data = { + "name": "test", + "commit_fields": [{"name": "foo"}], + } + schema = parse_schema(data) + self.assertFalse(schema.commit_fields[0].display) + + +class TestDataclassImmutability(unittest.TestCase): + """Schema dataclasses should be frozen.""" + + def test_commit_field_frozen(self): + cf = CommitField(name="x") + with self.assertRaises(AttributeError): + cf.name = "y" + + def test_machine_field_frozen(self): + mf = MachineField(name="x") + with self.assertRaises(AttributeError): + mf.name = "y" + + def test_metric_frozen(self): + m = Metric(name="x") + with self.assertRaises(AttributeError): + m.name = "y" + + +if __name__ == '__main__': + unittest.main(argv=[sys.argv[0]], exit=True) diff --git a/tests/server/db/v5/test_time_series.py b/tests/server/db/v5/test_time_series.py new file mode 100644 index 000000000..5f959fff7 --- /dev/null +++ b/tests/server/db/v5/test_time_series.py @@ -0,0 +1,333 @@ +# RUN: rm -rf %t.instance %t.pg.log +# RUN: %{utils}/with_postgres.sh %t.pg.log \ +# RUN: python %s +# END. + +import datetime +import os +import sys +import unittest + +import sqlalchemy +import sqlalchemy.orm + +from lnt.server.db.v5.schema import parse_schema +from lnt.server.db.v5.models import create_suite_models +from lnt.server.db.v5 import V5TestSuiteDB + + +def _make_engine(): + db_uri = os.environ.get('LNT_TEST_DB_URI') + db_name = os.environ.get('LNT_TEST_DB_NAME') + if not db_uri or not db_name: + raise unittest.SkipTest( + "LNT_TEST_DB_URI / LNT_TEST_DB_NAME not set") + return sqlalchemy.create_engine(f"{db_uri}/{db_name}") + + +def _test_schema(): + return parse_schema({ + "name": "ts", + "metrics": [ + {"name": "execution_time", "type": "real"}, + ], + "commit_fields": [ + {"name": "author", "searchable": True}, + ], + "machine_fields": [ + {"name": "hardware", "searchable": True}, + ], + }) + + +class TestTimeSeries(unittest.TestCase): + + @classmethod + def setUpClass(cls): + cls.engine = _make_engine() + cls.schema = _test_schema() + cls.suite_models = create_suite_models(cls.schema) + cls.suite_models.base.metadata.drop_all(cls.engine) + cls.suite_models.base.metadata.create_all(cls.engine) + cls.Session = sqlalchemy.orm.sessionmaker(cls.engine) + + class _FakeV5DB: + pass + cls.tsdb = V5TestSuiteDB(_FakeV5DB(), cls.schema, cls.suite_models) + + # Seed test data + session = cls.Session(expire_on_commit=False) + + cls.machine = cls.tsdb.get_or_create_machine( + session, "ts-machine", hardware="x86_64") + + cls.test = cls.tsdb.get_or_create_test(session, "ts-test/bench") + + # Create 5 commits with ordinals + cls.commits = [] + for i in range(5): + c = cls.tsdb.get_or_create_commit( + session, f"commit-{i}", author=f"Author-{i}") + c.ordinal = (i + 1) * 10 # 10, 20, 30, 40, 50 + cls.commits.append(c) + session.flush() + + # Create a commit WITHOUT ordinal + cls.unordered_commit = cls.tsdb.get_or_create_commit( + session, "unordered-commit") + session.flush() + + # Create runs and samples + base_time = datetime.datetime(2024, 1, 1, 12, 0, 0) + cls.runs = [] + for i, c in enumerate(cls.commits): + run = cls.tsdb.create_run( + session, cls.machine, commit=c, + submitted_at=base_time + datetime.timedelta(hours=i)) + cls.tsdb.create_samples(session, run, [{ + "test_id": cls.test.id, + "execution_time": float(i + 1), + }]) + cls.runs.append(run) + + # Run at unordered commit + cls.unordered_run = cls.tsdb.create_run( + session, cls.machine, commit=cls.unordered_commit, + submitted_at=base_time + datetime.timedelta(hours=10)) + cls.tsdb.create_samples(session, cls.unordered_run, [{ + "test_id": cls.test.id, + "execution_time": 99.0, + }]) + + session.commit() + session.close() + + @classmethod + def tearDownClass(cls): + cls.suite_models.base.metadata.drop_all(cls.engine) + cls.engine.dispose() + + def test_basic_query(self): + session = self.Session() + results = self.tsdb.query_time_series( + session, self.machine, self.test, "execution_time") + # Should include all 5 ordered + 1 unordered commits (6 total) + # (commitless run excluded because it has no commit join) + self.assertEqual(len(results), 6) + session.close() + + def test_sort_by_ordinal(self): + """Sorting by ordinal excludes unordered commits.""" + session = self.Session() + results = self.tsdb.query_time_series( + session, self.machine, self.test, "execution_time", + sort="ordinal") + # Only 5 commits with ordinals + self.assertEqual(len(results), 5) + ordinals = [r["ordinal"] for r in results] + self.assertEqual(ordinals, [10, 20, 30, 40, 50]) + session.close() + + def test_commit_range(self): + session = self.Session() + results = self.tsdb.query_time_series( + session, self.machine, self.test, "execution_time", + commit_range=(20, 40)) + ordinals = [r["ordinal"] for r in results] + self.assertEqual(len(results), 3) + for o in ordinals: + self.assertGreaterEqual(o, 20) + self.assertLessEqual(o, 40) + session.close() + + def test_time_range(self): + session = self.Session() + start = datetime.datetime(2024, 1, 1, 13, 0, 0) # after first run + end = datetime.datetime(2024, 1, 1, 15, 0, 0) # up to 3rd run + results = self.tsdb.query_time_series( + session, self.machine, self.test, "execution_time", + time_range=(start, end)) + self.assertGreater(len(results), 0) + for r in results: + self.assertGreaterEqual(r["submitted_at"], start) + self.assertLessEqual(r["submitted_at"], end) + session.close() + + def test_create_run_without_commit_raises(self): + session = self.Session() + with self.assertRaises(ValueError): + self.tsdb.create_run( + session, self.machine, commit=None, + submitted_at=datetime.datetime(2024, 1, 1, 12, 0, 0)) + session.close() + + def test_unknown_metric_raises(self): + session = self.Session() + with self.assertRaises(ValueError): + self.tsdb.query_time_series( + session, self.machine, self.test, "nonexistent_metric") + session.close() + + def test_limit(self): + session = self.Session() + results = self.tsdb.query_time_series( + session, self.machine, self.test, "execution_time", + limit=2) + self.assertEqual(len(results), 2) + session.close() + + def test_result_structure(self): + session = self.Session() + results = self.tsdb.query_time_series( + session, self.machine, self.test, "execution_time", + sort="ordinal", limit=1) + self.assertEqual(len(results), 1) + r = results[0] + self.assertIn("commit", r) + self.assertIn("ordinal", r) + self.assertIn("value", r) + self.assertIn("run_id", r) + self.assertIn("submitted_at", r) + session.close() + + +class TestQueryTrends(unittest.TestCase): + """Tests for V5TestSuiteDB.query_trends() geomean aggregation.""" + + @classmethod + def setUpClass(cls): + cls.engine = _make_engine() + cls.schema = _test_schema() + cls.suite_models = create_suite_models(cls.schema) + cls.suite_models.base.metadata.drop_all(cls.engine) + cls.suite_models.base.metadata.create_all(cls.engine) + cls.Session = sqlalchemy.orm.sessionmaker(cls.engine) + + class _FakeV5DB: + pass + cls.tsdb = V5TestSuiteDB(_FakeV5DB(), cls.schema, cls.suite_models) + + # Seed data: 2 machines, 3 commits, multiple tests per commit + session = cls.Session(expire_on_commit=False) + + cls.machine_a = cls.tsdb.get_or_create_machine( + session, "trends-machine-a", hardware="x86_64") + cls.machine_b = cls.tsdb.get_or_create_machine( + session, "trends-machine-b", hardware="arm64") + + cls.test1 = cls.tsdb.get_or_create_test(session, "trends/bench1") + cls.test2 = cls.tsdb.get_or_create_test(session, "trends/bench2") + + cls.commits = [] + base_time = datetime.datetime(2024, 3, 1, 12, 0, 0) + for i in range(3): + c = cls.tsdb.get_or_create_commit(session, f"trends-commit-{i}") + c.ordinal = (i + 1) * 10 # 10, 20, 30 + cls.commits.append(c) + session.flush() + + # Create runs and samples for machine_a + for i, c in enumerate(cls.commits): + run = cls.tsdb.create_run( + session, cls.machine_a, commit=c, + submitted_at=base_time + datetime.timedelta(hours=i)) + # Two tests per run with known positive values + cls.tsdb.create_samples(session, run, [ + {"test_id": cls.test1.id, "execution_time": 2.0}, + {"test_id": cls.test2.id, "execution_time": 8.0}, + ]) + + # Create runs and samples for machine_b (only first 2 commits) + for i, c in enumerate(cls.commits[:2]): + run = cls.tsdb.create_run( + session, cls.machine_b, commit=c, + submitted_at=base_time + datetime.timedelta(hours=i + 10)) + cls.tsdb.create_samples(session, run, [ + {"test_id": cls.test1.id, "execution_time": 4.0}, + ]) + + session.commit() + session.close() + + @classmethod + def tearDownClass(cls): + cls.suite_models.base.metadata.drop_all(cls.engine) + cls.engine.dispose() + + def test_basic_query_trends(self): + """query_trends returns geomean-aggregated data.""" + session = self.Session() + results = self.tsdb.query_trends(session, "execution_time") + self.assertGreater(len(results), 0) + # Check structure + r = results[0] + self.assertIn("machine_name", r) + self.assertIn("commit", r) + self.assertIn("ordinal", r) + self.assertIn("value", r) + self.assertIn("submitted_at", r) + session.close() + + def test_query_trends_geomean_value(self): + """Verify the geomean is computed correctly for machine_a.""" + import math + session = self.Session() + results = self.tsdb.query_trends( + session, "execution_time", + machine_ids=[self.machine_a.id]) + # Machine A has 3 commits, each with values [2.0, 8.0] + # geomean(2, 8) = exp(avg(ln(2), ln(8))) = exp((ln2+ln8)/2) + # = exp(ln(2*8)/2) = exp(ln(16)/2) = sqrt(16) = 4.0 + for r in results: + self.assertEqual(r["machine_name"], "trends-machine-a") + self.assertAlmostEqual(r["value"], 4.0, places=5) + self.assertEqual(len(results), 3) + session.close() + + def test_query_trends_filter_by_machine(self): + """Filter by machine_ids returns only that machine's data.""" + session = self.Session() + results = self.tsdb.query_trends( + session, "execution_time", + machine_ids=[self.machine_b.id]) + for r in results: + self.assertEqual(r["machine_name"], "trends-machine-b") + # Machine B only has 2 commits + self.assertEqual(len(results), 2) + session.close() + + def test_query_trends_filter_by_time_range(self): + """Filter by time_range restricts results.""" + session = self.Session() + start = datetime.datetime(2024, 3, 1, 12, 0, 0) + end = datetime.datetime(2024, 3, 1, 13, 30, 0) + results = self.tsdb.query_trends( + session, "execution_time", + time_range=(start, end)) + # Only commits within the time range for machine_a + for r in results: + self.assertIsNotNone(r["submitted_at"]) + self.assertLessEqual(r["submitted_at"], end) + self.assertGreaterEqual(r["submitted_at"], start) + session.close() + + def test_query_trends_unknown_metric_raises(self): + """Unknown metric name raises ValueError.""" + session = self.Session() + with self.assertRaises(ValueError): + self.tsdb.query_trends(session, "nonexistent_metric") + session.close() + + def test_query_trends_ordered_by_ordinal(self): + """Results are ordered by ordinal.""" + session = self.Session() + results = self.tsdb.query_trends( + session, "execution_time", + machine_ids=[self.machine_a.id]) + ordinals = [r["ordinal"] for r in results] + self.assertEqual(ordinals, sorted(ordinals)) + session.close() + + +if __name__ == '__main__': + unittest.main(argv=[sys.argv[0]], exit=True) diff --git a/tests/utils/with_temporary_instance.py b/tests/utils/with_temporary_instance.py index ab9581bca..148c22fa9 100755 --- a/tests/utils/with_temporary_instance.py +++ b/tests/utils/with_temporary_instance.py @@ -14,6 +14,78 @@ import sys +def _setup_v5_instance(dest_dir): + """Patch a freshly-created LNT instance for v5 and create a test suite. + + After ``lnt create`` has built the directory structure and lnt.cfg, + this function: + 1. Patches lnt.cfg to set ``db_version: '5.0'`` on the default database. + 2. Boots the app (which creates V5DB global tables). + 3. Creates an NTS-equivalent test suite in the v5 schema. + """ + import re + + cfg_path = os.path.join(dest_dir, 'lnt.cfg') + with open(cfg_path) as f: + cfg_text = f.read() + + # Insert db_version into the default database entry. The template + # emits: 'default' : { 'path' : '...' } + cfg_text = re.sub( + r"('default'\s*:\s*\{)\s*'path'", + r"\1 'db_version': '5.0', 'path'", + cfg_text, + ) + with open(cfg_path, 'w') as f: + f.write(cfg_text) + + # Boot the app -- Config reads db_version and instantiates V5DB. + import lnt.server.ui.app + app = lnt.server.ui.app.App.create_standalone(dest_dir) + + from lnt.server.db.v5.schema import parse_schema + + nts_schema = parse_schema({ + 'name': 'nts', + 'metrics': [ + {'name': 'compile_time', 'type': 'real', + 'display_name': 'Compile Time', 'unit': 'seconds', + 'unit_abbrev': 's'}, + {'name': 'compile_status', 'type': 'status'}, + {'name': 'execution_time', 'type': 'real', + 'display_name': 'Execution Time', 'unit': 'seconds', + 'unit_abbrev': 's'}, + {'name': 'execution_status', 'type': 'status'}, + {'name': 'score', 'type': 'real', 'bigger_is_better': True, + 'display_name': 'Score'}, + {'name': 'mem_bytes', 'type': 'real', + 'display_name': 'Memory Usage', 'unit': 'bytes', + 'unit_abbrev': 'b'}, + {'name': 'hash', 'type': 'hash'}, + {'name': 'hash_status', 'type': 'status'}, + {'name': 'code_size', 'type': 'real', + 'display_name': 'Code Size', 'unit': 'bytes', + 'unit_abbrev': 'b'}, + ], + 'commit_fields': [ + {'name': 'llvm_project_revision', 'searchable': True, + 'display': True}, + ], + 'machine_fields': [ + {'name': 'hardware', 'searchable': True}, + {'name': 'os', 'searchable': True}, + ], + }) + + db = app.instance.get_database("default") + session = db.make_session() + try: + db.create_suite(session, nts_schema) + session.commit() + finally: + session.close() + + def main(): parser = argparse.ArgumentParser( description="Create a temporary LNT instance backed by PostgreSQL and optionally import " @@ -27,6 +99,8 @@ def main(): parser.add_argument('data_dirs', metavar='DATA_DIR', nargs='*', help='directories containing JSON report files to import, ' 'or individual JSON report files') + parser.add_argument('--db-version', default='0.4', choices=['0.4', '5.0'], + help='database version to use (default: 0.4)') # Split at '--' to separate instance arguments from the command to exec. argv = sys.argv[1:] @@ -64,19 +138,25 @@ def main(): os.path.join(schemas_dst, schema), ) - # 3. Import JSON report files from each DATA_DIR (or individual file). - for data_path in data_dirs: - if os.path.isdir(data_path): - json_files = sorted(glob.glob(os.path.join(data_path, '*.json'))) - else: - json_files = [data_path] - for json_file in json_files: - with open(json_file) as f: - data = json.load(f) - suite = data.get('schema', 'nts') - subprocess.check_call(['lnt', 'import', '-s', suite, '--merge', 'append', dest_dir, json_file]) - - # 4. Exec the wrapped command. + # 3. For v5, patch the config and create the test suite programmatically. + if args.db_version == '5.0': + _setup_v5_instance(dest_dir) + + # 4. Import JSON report files from each DATA_DIR (or individual file). + # Skip for v5 -- the v4 import pipeline won't work. + if args.db_version == '0.4': + for data_path in data_dirs: + if os.path.isdir(data_path): + json_files = sorted(glob.glob(os.path.join(data_path, '*.json'))) + else: + json_files = [data_path] + for json_file in json_files: + with open(json_file) as f: + data = json.load(f) + suite = data.get('schema', 'nts') + subprocess.check_call(['lnt', 'import', '-s', suite, '--merge', 'append', dest_dir, json_file]) + + # 5. Exec the wrapped command. os.execvp(command[0], command) From eb8ac5bf3e148d708b0b691dd92ba87ea3088428 Mon Sep 17 00:00:00 2001 From: Louis Dionne Date: Mon, 13 Apr 2026 21:37:04 -0400 Subject: [PATCH 037/143] [API] Rewrite foundation: middleware, helpers, schemas, test infra for v5 DB Co-Authored-By: Claude Opus 4.6 (1M context) --- lnt/server/api/v5/endpoints/__init__.py | 6 +- lnt/server/api/v5/helpers.py | 169 +++++++--------------- lnt/server/api/v5/middleware.py | 13 +- lnt/server/api/v5/schemas/commits.py | 95 +++++++++++++ lnt/server/api/v5/schemas/orders.py | 136 ------------------ lnt/server/api/v5/schemas/regressions.py | 12 +- tests/server/api/v5/v5_test_helpers.py | 170 +++++++++-------------- 7 files changed, 229 insertions(+), 372 deletions(-) create mode 100644 lnt/server/api/v5/schemas/commits.py delete mode 100644 lnt/server/api/v5/schemas/orders.py diff --git a/lnt/server/api/v5/endpoints/__init__.py b/lnt/server/api/v5/endpoints/__init__.py index 06248154a..6de8ccd39 100644 --- a/lnt/server/api/v5/endpoints/__init__.py +++ b/lnt/server/api/v5/endpoints/__init__.py @@ -14,15 +14,15 @@ _ENDPOINT_MODULES = [ 'discovery', 'test_suites', + 'commits', 'machines', - 'orders', 'runs', 'tests', 'samples', 'profiles', - 'regressions', - 'field_changes', 'query', + 'field_changes', + 'regressions', 'trends', 'admin', ] diff --git a/lnt/server/api/v5/helpers.py b/lnt/server/api/v5/helpers.py index 9cfb95af2..c1e77ef48 100644 --- a/lnt/server/api/v5/helpers.py +++ b/lnt/server/api/v5/helpers.py @@ -31,28 +31,28 @@ def escape_like(pattern): return pattern.replace('\\', '\\\\').replace('%', r'\%').replace('_', r'\_') -def validate_tag(tag): - """Validate and normalize a tag value. +def validate_metric_name(ts, field_name): + """Validate that *field_name* is a known metric for this test suite. - Returns the normalized tag (None for empty strings) or aborts with - 400 if the value is invalid. + Aborts with 400 if the metric is not found. Returns *field_name* + unchanged on success. """ - if tag is not None and (not isinstance(tag, str) or len(tag) > 64): - abort_with_error(400, "'tag' must be a string of at most 64 characters") - return tag or None + if field_name not in ts._metric_names: + abort_with_error(400, "Unknown metric name '%s'" % field_name) + return field_name -def resolve_metric(ts, field_name): - """Resolve a metric name to its SampleField object. +def get_metric_def(ts, metric_name): + """Validate *metric_name* and return its schema Metric definition. - Searches the test suite's cached ``sample_fields`` list for a field - whose name matches *field_name*. Returns the :class:`SampleField` on - success, or aborts with a 400 error if no match is found. + Aborts with 400 if the metric is not found. """ - for sf in ts.sample_fields: - if sf.name == field_name: - return sf - abort_with_error(400, "Unknown metric name '%s'" % field_name) + validate_metric_name(ts, metric_name) + for m in ts.schema.metrics: + if m.name == metric_name: + return m + # Unreachable if validate_metric_name passed + abort_with_error(400, "Unknown metric name '%s'" % metric_name) # --------------------------------------------------------------------------- @@ -60,30 +60,16 @@ def resolve_metric(ts, field_name): # --------------------------------------------------------------------------- def lookup_machine(session, ts, machine_name): - """Look up a machine by name. - - Returns the machine, or aborts with 404 if not found, or 409 if - multiple machines share the same name. - """ - machines = session.query(ts.Machine).filter( - ts.Machine.name == machine_name - ).all() - if len(machines) == 0: + """Look up a machine by name. Aborts with 404 if not found.""" + machine = ts.get_machine(session, name=machine_name) + if machine is None: abort_with_error(404, "Machine '%s' not found" % machine_name) - if len(machines) > 1: - ids = ', '.join(str(m.id) for m in machines) - abort_with_error( - 409, - "Multiple machines named '%s' exist (IDs: %s). " - "Use the v4 UI to merge or rename them." % (machine_name, ids)) - return machines[0] + return machine def lookup_run_by_uuid(session, ts, run_uuid): """Look up a Run by UUID. Aborts with 404 if not found.""" - run = session.query(ts.Run).filter( - ts.Run.uuid == run_uuid - ).first() + run = ts.get_run(session, uuid=run_uuid) if run is None: abort_with_error(404, "Run '%s' not found" % run_uuid) return run @@ -91,19 +77,26 @@ def lookup_run_by_uuid(session, ts, run_uuid): def lookup_fieldchange(session, ts, fc_uuid): """Look up a FieldChange by UUID. Aborts with 404 if not found.""" - fc = session.query(ts.FieldChange).filter( - ts.FieldChange.uuid == fc_uuid - ).first() + fc = ts.get_field_change(session, uuid=fc_uuid) if fc is None: abort_with_error(404, "Field change '%s' not found" % fc_uuid) return fc +def lookup_commit(session, ts, commit_id): + """Look up a Commit by its identity string (e.g. git SHA). + + Aborts with 404 if not found. + """ + commit_obj = ts.get_commit(session, commit=commit_id) + if commit_obj is None: + abort_with_error(404, "Commit '%s' not found" % commit_id) + return commit_obj + + def lookup_test(session, ts, test_name): """Look up a Test by name. Aborts with 404 if not found.""" - test = session.query(ts.Test).filter( - ts.Test.name == test_name - ).first() + test = ts.get_test(session, name=test_name) if test is None: abort_with_error(404, "Test '%s' not found" % test_name) return test @@ -111,9 +104,7 @@ def lookup_test(session, ts, test_name): def lookup_regression(session, ts, regression_uuid): """Look up a Regression by UUID. Aborts with 404 if not found.""" - regression = session.query(ts.Regression).filter( - ts.Regression.uuid == regression_uuid - ).first() + regression = ts.get_regression(session, uuid=regression_uuid) if regression is None: abort_with_error(404, "Regression '%s' not found" % regression_uuid) return regression @@ -123,54 +114,24 @@ def lookup_regression(session, ts, regression_uuid): # Serialization helpers # --------------------------------------------------------------------------- -def serialize_order(order): - """Convert an Order model to a dict of field names to string values.""" - order_dict = {} - if order: - for field in order.fields: - val = order.get_field(field) - if val is not None: - order_dict[field.name] = str(val) - return order_dict - - def serialize_run(run, ts): """Serialize a Run model instance for API responses. - Returns a dict with uuid, machine, order, start_time, end_time, - and parameters. Used by both the runs and machines endpoints. + Returns a dict with uuid, machine, commit, submitted_at, + and run_parameters. """ - order_dict = serialize_order(run.order) - - start_time = None - if run.start_time: - start_time = run.start_time.isoformat() - end_time = None - if run.end_time: - end_time = run.end_time.isoformat() - - # Machine name - machine_name = None - if run.machine: - machine_name = run.machine.name - - # Run parameters - parameters = {} - try: - params = run.parameters - if params: - for k, v in params.items(): - parameters[k] = str(v) - except (TypeError, ValueError): - pass + machine_name = run.machine.name if run.machine else None + + submitted_at = None + if run.submitted_at: + submitted_at = run.submitted_at.isoformat() return { 'uuid': run.uuid, 'machine': machine_name, - 'order': order_dict, - 'start_time': start_time, - 'end_time': end_time, - 'parameters': parameters, + 'commit': run.commit_obj.commit if run.commit_obj else None, + 'submitted_at': submitted_at, + 'run_parameters': dict(run.run_parameters) if run.run_parameters else {}, } @@ -178,44 +139,16 @@ def serialize_fieldchange(fc): """Serialize the common fields of a FieldChange for API responses. Returns a dict with test, machine, metric, old_value, new_value, - start_order, end_order, and run_uuid. Callers should add an - identifier key (``uuid`` or ``field_change_uuid``) to the result - before returning it to the client. + start_commit, and end_commit. Callers should add an identifier key + (``uuid`` or ``field_change_uuid``) to the result before returning + it to the client. """ - # Get field name from the SampleField relation - field_name = None - if fc.field is not None: - field_name = fc.field.name - - # Get order field values - start_order_val = None - if fc.start_order is not None: - for field in fc.start_order.fields: - val = fc.start_order.get_field(field) - if val is not None: - start_order_val = str(val) - break - - end_order_val = None - if fc.end_order is not None: - for field in fc.end_order.fields: - val = fc.end_order.get_field(field) - if val is not None: - end_order_val = str(val) - break - - # Get run UUID - run_uuid = None - if fc.run is not None: - run_uuid = fc.run.uuid - return { 'test': fc.test.name if fc.test else None, 'machine': fc.machine.name if fc.machine else None, - 'metric': field_name, + 'metric': fc.field_name, 'old_value': fc.old_value, 'new_value': fc.new_value, - 'start_order': start_order_val, - 'end_order': end_order_val, - 'run_uuid': run_uuid, + 'start_commit': fc.start_commit.commit if fc.start_commit else None, + 'end_commit': fc.end_commit.commit if fc.end_commit else None, } diff --git a/lnt/server/api/v5/middleware.py b/lnt/server/api/v5/middleware.py index 86961a290..7075282b9 100644 --- a/lnt/server/api/v5/middleware.py +++ b/lnt/server/api/v5/middleware.py @@ -40,18 +40,15 @@ def v5_before_request(): g.db_name = "default" g.db_session = db.make_session() - # Check whether another worker has created/deleted a suite. - db.check_registry_version(g.db_session) - # Resolve testsuite from view_args if the URL contains one. # Discovery (/api/v5/) and admin (/api/v5/admin/) paths have no - # testsuite in the URL. + # testsuite in the URL. get_suite() handles schema version + # staleness checks transparently. view_args = request.view_args or {} testsuite = view_args.get('testsuite') if testsuite: - if testsuite not in db.testsuite: - # Return a proper JSON error directly from middleware, - # avoiding the v4 HTML error handler. + ts = db.get_suite(testsuite, g.db_session) + if ts is None: resp = jsonify({ 'error': { 'code': 'not_found', @@ -60,7 +57,7 @@ def v5_before_request(): }) resp.status_code = 404 return resp - g.ts = db.testsuite[testsuite] + g.ts = ts @app.teardown_request def v5_teardown_request(exc): diff --git a/lnt/server/api/v5/schemas/commits.py b/lnt/server/api/v5/schemas/commits.py new file mode 100644 index 000000000..05e57c2c0 --- /dev/null +++ b/lnt/server/api/v5/schemas/commits.py @@ -0,0 +1,95 @@ +"""Marshmallow schemas for commit request/response in the v5 API. + +Commits replace the v4 "orders" concept. Each commit has a unique +commit string, an optional integer ordinal for sorting, and dynamic +commit_fields defined in the test suite schema. +""" + +import marshmallow as ma + +from . import BaseSchema +from .common import BaseQuerySchema, CursorPaginationQuerySchema, PaginatedResponseSchema + + +# --------------------------------------------------------------------------- +# Response schemas +# --------------------------------------------------------------------------- + +class CommitSummarySchema(BaseSchema): + """A single commit in a list response.""" + commit = ma.fields.String( + required=True, + metadata={'description': 'Unique commit identifier (e.g. git SHA)'}, + ) + ordinal = ma.fields.Integer( + allow_none=True, + metadata={'description': 'Optional integer for total ordering'}, + ) + fields = ma.fields.Dict( + keys=ma.fields.String(), + values=ma.fields.Raw(allow_none=True), + metadata={ + 'description': 'Commit field values defined by the test suite schema', + 'example': {'llvm_project_revision': 'abc123'}, + }, + ) + + +class CommitNeighborSchema(BaseSchema): + """Reference to a previous or next commit.""" + commit = ma.fields.String( + metadata={'description': 'Commit identifier'}, + ) + ordinal = ma.fields.Integer( + allow_none=True, + metadata={'description': 'Ordinal value'}, + ) + link = ma.fields.String( + allow_none=True, + metadata={'description': 'URL to fetch the referenced commit'}, + ) + + +class CommitDetailSchema(BaseSchema): + """Full commit detail including previous/next neighbors.""" + commit = ma.fields.String(required=True) + ordinal = ma.fields.Integer(allow_none=True) + fields = ma.fields.Dict( + keys=ma.fields.String(), + values=ma.fields.Raw(allow_none=True), + ) + previous_commit = ma.fields.Nested( + CommitNeighborSchema, allow_none=True, + metadata={'description': 'Previous commit by ordinal'}, + ) + next_commit = ma.fields.Nested( + CommitNeighborSchema, allow_none=True, + metadata={'description': 'Next commit by ordinal'}, + ) + + +# --------------------------------------------------------------------------- +# Paginated response schemas +# --------------------------------------------------------------------------- + +class PaginatedCommitResponseSchema(PaginatedResponseSchema): + """Paginated list of commits.""" + items = ma.fields.List(ma.fields.Nested(CommitSummarySchema)) + + +# --------------------------------------------------------------------------- +# Query parameter schemas +# --------------------------------------------------------------------------- + +class CommitListQuerySchema(CursorPaginationQuerySchema): + """Query parameters for GET /commits.""" + search = ma.fields.String( + load_default=None, + metadata={'description': 'Search commits by prefix across commit ' + 'string and searchable commit fields'}, + ) + + +class CommitDetailQuerySchema(BaseQuerySchema): + """Query parameters for GET /commits/{value}.""" + pass diff --git a/lnt/server/api/v5/schemas/orders.py b/lnt/server/api/v5/schemas/orders.py deleted file mode 100644 index 149121b54..000000000 --- a/lnt/server/api/v5/schemas/orders.py +++ /dev/null @@ -1,136 +0,0 @@ -"""Order request/response schemas for the v5 API. - -Used by the orders endpoints for OpenAPI documentation and (optionally) -for validation. The dynamic order fields are serialized into a ``fields`` -dict since their names depend on the test suite schema. -""" - -import marshmallow as ma - -from . import BaseSchema -from .common import BaseQuerySchema, CursorPaginationQuerySchema, PaginatedResponseSchema - - -# --------------------------------------------------------------------------- -# Response schemas -# --------------------------------------------------------------------------- - -class OrderSummarySchema(BaseSchema): - """A single order in a list response.""" - fields = ma.fields.Dict( - keys=ma.fields.String(), - values=ma.fields.String(allow_none=True), - metadata={ - 'description': 'Order field values (e.g. llvm_project_revision)', - 'example': {'llvm_project_revision': 'abc123'}, - }, - ) - tag = ma.fields.String( - allow_none=True, - metadata={ - 'description': 'User-assigned label (e.g. release-18.1)', - 'example': 'release-18.1', - }, - ) - - -class OrderNeighborSchema(BaseSchema): - """Reference to a previous or next order.""" - fields = ma.fields.Dict( - keys=ma.fields.String(), - values=ma.fields.String(allow_none=True), - metadata={ - 'description': 'Order field values', - 'example': {'llvm_project_revision': 'abc123'}, - }, - ) - link = ma.fields.String( - allow_none=True, - metadata={'description': 'URL to fetch the referenced order'}, - ) - - -class OrderDetailSchema(BaseSchema): - """Full order detail including previous/next references.""" - fields = ma.fields.Dict( - keys=ma.fields.String(), - values=ma.fields.String(allow_none=True), - metadata={ - 'description': 'Order field values', - 'example': {'llvm_project_revision': 'abc123'}, - }, - ) - tag = ma.fields.String( - allow_none=True, - metadata={ - 'description': 'User-assigned label (e.g. release-18.1)', - 'example': 'release-18.1', - }, - ) - previous_order = ma.fields.Nested( - OrderNeighborSchema, allow_none=True, - metadata={'description': 'Previous order in the total ordering'}, - ) - next_order = ma.fields.Nested( - OrderNeighborSchema, allow_none=True, - metadata={'description': 'Next order in the total ordering'}, - ) - - -# --------------------------------------------------------------------------- -# Request schemas -# --------------------------------------------------------------------------- - -class OrderCreateSchema(BaseSchema): - """Request body for POST /orders. - - The body should contain the order field values as top-level keys - (e.g. ``{"llvm_project_revision": "abc123"}``). - """ - class Meta: - # Allow any keys since order fields are dynamic per test suite - unknown = ma.INCLUDE - - -class OrderUpdateSchema(BaseSchema): - """Request body for PATCH /orders/{order_value}. - - Currently a placeholder -- order metadata updates are limited until - a ``parameters_data`` column is added to the Order model. - """ - class Meta: - unknown = ma.INCLUDE - - -# --------------------------------------------------------------------------- -# Paginated response schemas -# --------------------------------------------------------------------------- - -class PaginatedOrderResponseSchema(PaginatedResponseSchema): - """Paginated list of orders.""" - items = ma.fields.List(ma.fields.Nested(OrderSummarySchema)) - - -# --------------------------------------------------------------------------- -# Query parameter schemas -# --------------------------------------------------------------------------- - -class OrderListQuerySchema(CursorPaginationQuerySchema): - """Query parameters for GET /orders.""" - tag = ma.fields.String( - load_default=None, - metadata={'description': 'Filter by exact tag'}, - ) - tag_prefix = ma.fields.String( - load_default=None, - metadata={'description': 'Filter by tag prefix'}, - ) - - -class OrderDetailQuerySchema(BaseQuerySchema): - """Query parameters for GET /orders/{order_value}. - - Only covers marshmallow-parseable params. Dynamic order field names - for disambiguation continue to be read from request.args directly. - """ - pass diff --git a/lnt/server/api/v5/schemas/regressions.py b/lnt/server/api/v5/schemas/regressions.py index 78c3c8afc..dc3211213 100644 --- a/lnt/server/api/v5/schemas/regressions.py +++ b/lnt/server/api/v5/schemas/regressions.py @@ -13,17 +13,17 @@ # --------------------------------------------------------------------------- -# State mapping: API string <-> DB integer +# State mapping: API string <-> DB integer (v5 values: 0-6) # --------------------------------------------------------------------------- STATE_TO_DB = { 'detected': 0, 'staged': 1, - 'active': 10, - 'not_to_be_fixed': 20, - 'ignored': 21, - 'fixed': 22, - 'detected_fixed': 23, + 'active': 2, + 'not_to_be_fixed': 3, + 'ignored': 4, + 'fixed': 5, + 'detected_fixed': 6, } DB_TO_STATE = {v: k for k, v in STATE_TO_DB.items()} diff --git a/tests/server/api/v5/v5_test_helpers.py b/tests/server/api/v5/v5_test_helpers.py index c6a9de2b4..42909e52f 100644 --- a/tests/server/api/v5/v5_test_helpers.py +++ b/tests/server/api/v5/v5_test_helpers.py @@ -4,12 +4,12 @@ - ``create_app`` -- Create a Flask app from an instance path - ``create_client`` -- Return a Flask test client - Auth helpers for creating API keys and headers +- Data creation helpers using V5TestSuiteDB methods - API-based fixture helpers (submit_run, submit_fieldchange, etc.) -- Legacy DB helpers (create_machine, etc.) for tests that need direct - DB access (e.g. profile tests, duplicate-name edge cases) """ import datetime +import hashlib import uuid import lnt.server.ui.app @@ -35,117 +35,91 @@ def create_client(app): # Auth helpers # --------------------------------------------------------------------------- +def make_api_key(session, name, scope, raw_token): + """Insert an APIKey row and return the Bearer header dict.""" + from lnt.server.api.v5.auth import APIKey + key_hash = hashlib.sha256(raw_token.encode('utf-8')).hexdigest() + api_key = APIKey( + name=name, + key_prefix=raw_token[:8], + key_hash=key_hash, + scope=scope, + created_at=datetime.datetime.utcnow(), + is_active=True, + ) + session.add(api_key) + session.commit() + return {'Authorization': f'Bearer {raw_token}'} + + def admin_headers(): """Auth headers using the bootstrap api_auth_token (admin scope).""" return {'Authorization': 'Bearer test_token'} def make_scoped_headers(app, scope_name): - """Create an API key via the admin endpoint and return Bearer headers.""" - client = app.test_client() - resp = client.post( - '/api/v5/admin/api-keys', - json={'name': f'test-{scope_name}', 'scope': scope_name}, - headers=admin_headers(), - ) - assert resp.status_code == 201, ( - f"API key creation failed: {resp.get_json()}") - data = resp.get_json() - return {'Authorization': f'Bearer {data["key"]}'} + """Create an API key with the given scope and return Bearer headers.""" + db = app.instance.get_database("default") + session = db.make_session() + token = f'{scope_name}token_{uuid.uuid4().hex[:20]}' + headers = make_api_key(session, f'test-{scope_name}', scope_name, token) + session.close() + return headers # --------------------------------------------------------------------------- -# Legacy DB helpers (kept for test_samples.py, test_profiles.py, and -# TestDuplicateMachineNames which require direct DB access) +# Data creation helpers -- use V5TestSuiteDB methods # --------------------------------------------------------------------------- def create_machine(session, ts, name='test-machine', **info_fields): - """Create a Machine and return it.""" - machine = ts.Machine(name) - declared = {f.name for f in ts.machine_fields} - params = {} - for key, value in info_fields.items(): - if key in declared: - setattr(machine, key, value) - else: - params[key] = value - if params: - machine.parameters = params - session.add(machine) - session.flush() - return machine - - -def create_order(session, ts, revision='1'): - """Create an Order and return it.""" - order = ts.Order() - order.set_field(ts.order_fields[0], revision) - session.add(order) - session.flush() - return order - - -def create_run(session, ts, machine, order, - start_time=None, end_time=None): - """Create a Run and return it.""" - if start_time is None: - start_time = datetime.datetime(2024, 1, 1, 12, 0, 0) - if end_time is None: - end_time = datetime.datetime(2024, 1, 1, 12, 30, 0) - run = ts.Run(None, machine, order, start_time, end_time) - run.uuid = str(uuid.uuid4()) - run.parameters = {} - session.add(run) - session.flush() - return run + """Create a Machine via V5TestSuiteDB and return it.""" + schema_fields = {k: v for k, v in info_fields.items() + if k in ts._machine_field_names} + params = {k: v for k, v in info_fields.items() + if k not in ts._machine_field_names} + return ts.get_or_create_machine( + session, name, parameters=params or None, **schema_fields) + + +def create_commit(session, ts, commit='rev-1', **metadata): + """Create a Commit via V5TestSuiteDB and return it.""" + return ts.get_or_create_commit(session, commit, **metadata) + + +def create_run(session, ts, machine, commit, + submitted_at=None): + """Create a Run via V5TestSuiteDB and return it.""" + if submitted_at is None: + submitted_at = datetime.datetime(2024, 1, 1, 12, 0, 0) + return ts.create_run(session, machine, commit=commit, + submitted_at=submitted_at) def create_test(session, ts, name='test.suite/benchmark'): - """Create a Test and return it.""" - test = ts.Test(name) - session.add(test) - session.flush() - return test + """Create a Test via V5TestSuiteDB and return it.""" + return ts.get_or_create_test(session, name) def create_sample(session, ts, run, test, **field_values): - """Create a Sample and return it.""" - sample = ts.Sample(run, test, **field_values) - session.add(sample) - session.flush() - return sample - - -def create_fieldchange(session, ts, start_order, end_order, machine, test, - field, old_value=1.0, new_value=2.0, run=None): - """Create a FieldChange and return it.""" - fc = ts.FieldChange(start_order=start_order, end_order=end_order, - machine=machine, test=test, field_id=field.id) - fc.uuid = str(uuid.uuid4()) - fc.old_value = old_value - fc.new_value = new_value - if run: - fc.run = run - session.add(fc) - session.flush() - return fc + """Create a Sample via V5TestSuiteDB and return it.""" + samples = ts.create_samples( + session, run, [{'test_id': test.id, **field_values}]) + return samples[0] + + +def create_fieldchange(session, ts, start_commit, end_commit, machine, test, + field_name, old_value=1.0, new_value=2.0): + """Create a FieldChange via V5TestSuiteDB and return it.""" + return ts.create_field_change( + session, machine, test, field_name, + start_commit, end_commit, old_value, new_value) def create_regression(session, ts, title='Test Regression', state=0, field_changes=None): """Create a Regression (optionally with indicators) and return it.""" - regression = ts.Regression(title, '', state) - regression.uuid = str(uuid.uuid4()) - session.add(regression) - session.flush() - - if field_changes: - for fc in field_changes: - ri = ts.RegressionIndicator(regression, fc) - session.add(ri) - session.flush() - - return regression + fc_ids = [fc.id for fc in field_changes] if field_changes else [] + return ts.create_regression(session, title, fc_ids, state=state) # --------------------------------------------------------------------------- @@ -182,22 +156,16 @@ def collect_all_pages(test_case, client, url, page_limit=20): # API-based fixture helpers # --------------------------------------------------------------------------- -def submit_run(client, machine_name, revision, tests, - start_time='2024-06-15T10:00:00', - end_time='2024-06-15T10:30:00', +def submit_run(client, machine_name, commit, tests, machine_info=None, testsuite='nts'): """Submit a run via POST and return response JSON (includes run_uuid).""" machine = {'name': machine_name} if machine_info: machine.update(machine_info) payload = { - 'format_version': '2', + 'format_version': '5', 'machine': machine, - 'run': { - 'start_time': start_time, - 'end_time': end_time, - 'llvm_project_revision': revision, - }, + 'commit': commit, 'tests': tests, } resp = client.post(f'/api/v5/{testsuite}/runs', json=payload, @@ -208,14 +176,14 @@ def submit_run(client, machine_name, revision, tests, def submit_fieldchange(client, app, machine, test, metric, - start_rev, end_rev, + start_commit, end_commit, old_value=10.0, new_value=20.0, testsuite='nts'): """Create a field change via POST and return response JSON.""" body = { 'machine': machine, 'test': test, 'metric': metric, 'old_value': old_value, 'new_value': new_value, - 'start_order': start_rev, 'end_order': end_rev, + 'start_commit': start_commit, 'end_commit': end_commit, } resp = client.post(f'/api/v5/{testsuite}/field-changes', json=body, headers=admin_headers()) From 6b90eb61ed5a6aeea140a22224ca4b1928ca3cdb Mon Sep 17 00:00:00 2001 From: Louis Dionne Date: Mon, 13 Apr 2026 21:37:14 -0400 Subject: [PATCH 038/143] [API] Rewrite read-only endpoints (discovery, agents, tests, samples) for v5 DB Co-Authored-By: Claude Opus 4.6 (1M context) --- lnt/server/api/v5/endpoints/agents.py | 30 ++-- lnt/server/api/v5/endpoints/samples.py | 17 +-- lnt/server/api/v5/endpoints/test_suites.py | 123 ++-------------- lnt/server/api/v5/endpoints/tests.py | 7 +- lnt/server/api/v5/schemas/common.py | 2 +- lnt/server/api/v5/schemas/samples.py | 14 +- tests/server/api/v5/test_agents.py | 2 +- tests/server/api/v5/test_discovery.py | 4 +- tests/server/api/v5/test_samples.py | 162 ++++----------------- tests/server/api/v5/test_tests.py | 2 +- 10 files changed, 79 insertions(+), 284 deletions(-) diff --git a/lnt/server/api/v5/endpoints/agents.py b/lnt/server/api/v5/endpoints/agents.py index 3829d0281..c34a247f0 100644 --- a/lnt/server/api/v5/endpoints/agents.py +++ b/lnt/server/api/v5/endpoints/agents.py @@ -24,18 +24,19 @@ ## Key Concepts - **Test Suite**: A schema defining what metrics to collect (e.g., "nts" for - the LLVM nightly test suite). Each suite has its own set of machines, orders, + the LLVM nightly test suite). Each suite has its own set of machines, commits, runs, and tests. All data queries are scoped to a specific test suite. - **Machine**: A build/test environment identified by name (e.g., "clang-x86_64-linux"). Machines have key-value info fields describing their configuration. -- **Order**: A point in the revision history (e.g., a commit hash or revision - number). Orders define the sequence for time-series analysis. They may have - multiple fields (e.g., primary revision + dependent project revisions). +- **Commit**: A named point that groups runs (e.g., a Git SHA, version number, + or ad-hoc label). Each commit has an optional integer ordinal that places it + in a total order for time-series analysis. Commits may have metadata fields + (e.g., author, commit_message) defined by the test suite schema. -- **Run**: A single test execution on a machine at a specific order. Contains +- **Run**: A single test execution on a machine at a specific commit. Contains samples (individual test results) with metric values. Identified by UUID. - **Test**: A named benchmark or test case (e.g., "SingleSource/Benchmarks/ @@ -50,7 +51,7 @@ title, and optional bug tracker link. - **Field Change**: A statistically significant change in a metric value - between two orders for a specific test on a specific machine. + between two commits for a specific test on a specific machine. ## REST API (v5) @@ -67,8 +68,8 @@ GET /api/v5/{ts}/machines List machines GET /api/v5/{ts}/machines/{name} Machine detail - GET /api/v5/{ts}/orders List orders - GET /api/v5/{ts}/orders/{value} Order detail (with prev/next) + GET /api/v5/{ts}/commits List commits + GET /api/v5/{ts}/commits/{value} Commit detail (with prev/next) GET /api/v5/{ts}/runs List runs POST /api/v5/{ts}/runs Submit a run GET /api/v5/{ts}/runs/{uuid} Run detail @@ -84,7 +85,7 @@ GET /api/v5/admin/api-keys List API keys (admin) The endpoints above cover the most common read operations. The API also -supports write operations (creating/updating/deleting machines, orders, +supports write operations (creating/updating/deleting machines, commits, runs, regressions, field changes, test suites, and API keys) which require appropriate authentication scopes. See the OpenAPI spec or Swagger UI for the complete endpoint list including all write operations. @@ -109,14 +110,17 @@ { "metric": "execution_time", "machine": "machine-name", "test": ["test/name"] } to get time-series data points. -3. Submit a run: POST /api/v5/{ts}/runs with the LNT JSON report format. - Requires a token with "submit" scope. +3. Submit a run: POST /api/v5/{ts}/runs with a JSON payload containing + format_version "5", machine, commit, and tests. Requires a token with + "submit" scope. 4. Check for regressions: GET /api/v5/{ts}/regressions?state=detected to find new regressions. PATCH to update state, title, or bug link. -5. Inspect a specific order: GET /api/v5/{ts}/orders/{value} returns - the order detail with previous/next navigation links. +5. Inspect a specific commit: GET /api/v5/{ts}/commits/{value} returns + the commit detail with previous/next navigation links. Use + PATCH /api/v5/{ts}/commits/{value} to assign an ordinal for time-series + ordering. """ _ETAG = hashlib.md5(LLMS_TEXT.encode()).hexdigest() diff --git a/lnt/server/api/v5/endpoints/samples.py b/lnt/server/api/v5/endpoints/samples.py index 16e60f48b..ccc28ab84 100644 --- a/lnt/server/api/v5/endpoints/samples.py +++ b/lnt/server/api/v5/endpoints/samples.py @@ -33,18 +33,17 @@ def _serialize_sample(sample, ts): """Serialize a Sample model instance for the API response. - Returns a dict with test_name, has_profile, and a metrics dict - containing all non-null sample field values. + Returns a dict with test name and a metrics dict containing all + non-null metric values. """ metrics = {} - for field in ts.sample_fields: - value = sample.get_field(field) + for metric in ts.schema.metrics: + value = getattr(sample, metric.name, None) if value is not None: - metrics[field.name] = value + metrics[metric.name] = value return { 'test': sample.test.name, - 'has_profile': sample.profile_id is not None, 'metrics': metrics, } @@ -58,7 +57,7 @@ class RunSamples(MethodView): @blp.response(200, PaginatedSampleResponseSchema) def get(self, query_args, testsuite, run_uuid): """List samples for a run (cursor-paginated).""" - reject_unknown_params({'has_profile', 'cursor', 'limit'}) + reject_unknown_params({'cursor', 'limit'}) ts = g.ts session = g.db_session run = lookup_run_by_uuid(session, ts, run_uuid) @@ -69,10 +68,6 @@ def get(self, query_args, testsuite, run_uuid): ts.Sample.run_id == run.id ) - # Apply has_profile filter - if query_args.get('has_profile') is True: - query = query.filter(ts.Sample.profile_id.isnot(None)) - cursor_str = query_args.get('cursor') limit = query_args['limit'] items, next_cursor = cursor_paginate( diff --git a/lnt/server/api/v5/endpoints/test_suites.py b/lnt/server/api/v5/endpoints/test_suites.py index 8b2d52a79..fb2e9c63f 100644 --- a/lnt/server/api/v5/endpoints/test_suites.py +++ b/lnt/server/api/v5/endpoints/test_suites.py @@ -10,8 +10,8 @@ from flask.views import MethodView from flask_smorest import Blueprint -from lnt.server.db import testsuite -import lnt.server.db.testsuitedb +from lnt.server.db.v5 import V5DB +from lnt.server.db.v5.schema import SchemaError, parse_schema from ..auth import require_scope from ..errors import abort_with_error, reject_unknown_params @@ -38,7 +38,7 @@ def _suite_links(name): prefix = '/api/v5/%s' % name return { 'machines': prefix + '/machines', - 'orders': prefix + '/orders', + 'commits': prefix + '/commits', 'runs': prefix + '/runs', 'tests': prefix + '/tests', 'regressions': prefix + '/regressions', @@ -52,7 +52,7 @@ def _suite_detail(db, name): tsdb = db.testsuite[name] return { 'name': name, - 'schema': tsdb.test_suite.__json__(), + 'schema': V5DB._schema_to_dict(tsdb.schema), 'links': _suite_links(name), } @@ -86,79 +86,35 @@ def post(self, query_args, payload): session = g.db_session name = payload['name'] - # Check the in-memory cache first + # Check the in-memory cache first. if name in db.testsuite: abort_with_error(409, "Test suite '%s' already exists" % name) - # Also check the DB metatable to guard against races - existing = session.query(testsuite.TestSuite).filter( - testsuite.TestSuite.name == name - ).first() - if existing is not None: - abort_with_error(409, "Test suite '%s' already exists" % name) - - # Build the TestSuite object from the payload + # Parse the payload into a v5 TestSuiteSchema. try: - suite = testsuite.TestSuite.from_json(payload) - except (ValueError, AssertionError, KeyError) as exc: + schema = parse_schema(payload) + except SchemaError as exc: abort_with_error(400, str(exc)) - # All creation steps are wrapped so that if any step fails, - # metadata is rolled back and any created tables are dropped. - # This avoids the bug where an early commit persists metadata - # rows but a later failure (e.g. in create_tables) leaves the - # database in an inconsistent state with no corresponding tables. - tsdb = None + # Create the suite (tables, schema row, version bump). try: - # Stage metadata rows without committing. For a brand-new - # suite we add the JSON schema row directly instead of calling - # check_testsuite_schema_changes (which commits internally). - schema = testsuite.TestSuiteJSONSchema(name, suite.jsonschema) - session.add(schema) - suite = testsuite.sync_testsuite_with_metatables(session, suite) - session.flush() - - # Create physical per-suite tables (DDL). We pass the - # session's connection instead of the engine so that the - # CREATE TABLE statements execute within the same transaction - # (and on the same DB connection) as the flushed metadata - # inserts. Using a separate connection would deadlock on - # PostgreSQL because FieldChange has a FK to SampleField: - # connection A holds ROW EXCLUSIVE on TestSuiteSampleFields - # from the flush, while connection B's CREATE TABLE needs - # SHARE ROW EXCLUSIVE on that same table. - tsdb = lnt.server.db.testsuitedb.TestSuiteDB(db, name, suite) - tsdb.create_tables(session.connection()) - - # Bump registry version so other workers pick up the change. - db.increment_registry_version(session) + db.create_suite(session, schema) session.commit() + except ValueError as exc: + session.rollback() + abort_with_error(409, str(exc)) except Exception as exc: session.rollback() - # Best-effort cleanup: drop tables that may have been created - # before the failure. - if tsdb is not None: - try: - tsdb.base.metadata.drop_all(db.engine) - except Exception: - pass abort_with_error(400, "Failed to create test suite '%s': %s" % (name, exc)) - db.testsuite[name] = tsdb - db.testsuite = dict(sorted(db.testsuite.items())) - @after_this_request def add_location_header(response): response.headers['Location'] = '/api/v5/test-suites/%s' % name return response - return { - 'name': name, - 'schema': suite.__json__(), - 'links': _suite_links(name), - } + return _suite_detail(db, name) @blp.route('/') @@ -197,60 +153,13 @@ def delete(self, query_args, suite_name): if suite_name not in db.testsuite: abort_with_error(404, "Test suite '%s' not found" % suite_name) - tsdb = db.testsuite[suite_name] - - # Deletion order is chosen for safety: metadata first, then tables, - # then in-memory dict. If metadata deletion fails, no tables are - # dropped and we can roll back cleanly. If table dropping fails - # *after* metadata is committed, we end up with orphaned tables - # (harmless) rather than metadata pointing at missing tables. - - # 1. Delete metadata rows and commit try: - ts_row = session.query(testsuite.TestSuite).filter( - testsuite.TestSuite.name == suite_name - ).first() - if ts_row is not None: - ts_id = ts_row.id - # Null out self-referential FK before deleting SampleFields - session.query(testsuite.SampleField).filter( - testsuite.SampleField.test_suite_id == ts_id - ).update({testsuite.SampleField.status_field_id: None}, - synchronize_session='fetch') - session.flush() - - # Delete field rows - for model in (testsuite.SampleField, testsuite.MachineField, - testsuite.OrderField, testsuite.RunField): - session.query(model).filter( - model.test_suite_id == ts_id - ).delete(synchronize_session='fetch') - - # Delete JSON schema row - session.query(testsuite.TestSuiteJSONSchema).filter( - testsuite.TestSuiteJSONSchema.testsuite_name == suite_name - ).delete(synchronize_session='fetch') - - # Delete the TestSuite row itself - session.delete(ts_row) - - db.increment_registry_version(session) + db.delete_suite(session, suite_name) session.commit() except Exception as exc: session.rollback() abort_with_error( 500, - "Failed to delete metadata for '%s': %s" % (suite_name, exc)) - - # 2. Drop per-suite tables (best-effort after metadata is gone) - try: - tsdb.base.metadata.drop_all(db.engine) - except Exception: - # Tables are orphaned but metadata is already gone — harmless. - # A future CREATE of the same suite will recreate them. - pass - - # 3. Remove from in-memory dict - del db.testsuite[suite_name] + "Failed to delete test suite '%s': %s" % (suite_name, exc)) return '', 204 diff --git a/lnt/server/api/v5/endpoints/tests.py b/lnt/server/api/v5/endpoints/tests.py index f06c4087b..9d9b3839f 100644 --- a/lnt/server/api/v5/endpoints/tests.py +++ b/lnt/server/api/v5/endpoints/tests.py @@ -11,7 +11,7 @@ from ..auth import require_scope from ..errors import reject_unknown_params from ..etag import add_etag_to_response -from ..helpers import escape_like, lookup_machine, lookup_test, resolve_metric +from ..helpers import escape_like, lookup_machine, lookup_test, validate_metric_name from ..pagination import ( cursor_paginate, make_paginated_response, @@ -64,8 +64,9 @@ def get(self, query_args, testsuite): query = query.join(ts.Run).filter( ts.Run.machine_id == machine.id) if metric_name: - field = resolve_metric(ts, metric_name) - query = query.filter(field.column.isnot(None)) + validate_metric_name(ts, metric_name) + metric_col = getattr(ts.Sample, metric_name) + query = query.filter(metric_col.isnot(None)) if machine_name or metric_name: query = query.distinct() diff --git a/lnt/server/api/v5/schemas/common.py b/lnt/server/api/v5/schemas/common.py index 326a5295a..fb0768579 100644 --- a/lnt/server/api/v5/schemas/common.py +++ b/lnt/server/api/v5/schemas/common.py @@ -51,7 +51,7 @@ class PaginatedResponseSchema(BaseSchema): class TestSuiteLinksSchema(BaseSchema): """Links to resources within a test suite.""" machines = ma.fields.String() - orders = ma.fields.String() + commits = ma.fields.String() runs = ma.fields.String() tests = ma.fields.String() regressions = ma.fields.String() diff --git a/lnt/server/api/v5/schemas/samples.py b/lnt/server/api/v5/schemas/samples.py index 6ea0c1665..5e6d8d3be 100644 --- a/lnt/server/api/v5/schemas/samples.py +++ b/lnt/server/api/v5/schemas/samples.py @@ -9,18 +9,13 @@ class SampleResponseSchema(BaseSchema): """Schema for a single sample in API responses. - Each sample includes the test name, a flag indicating whether it has - a profile, and a ``metrics`` dict containing all non-null sample field - values. + Each sample includes the test name and a ``metrics`` dict containing + all non-null metric values. """ test = ma.fields.String( required=True, metadata={'description': 'Name of the test this sample belongs to'}, ) - has_profile = ma.fields.Boolean( - required=True, - metadata={'description': 'Whether this sample has profile data'}, - ) metrics = ma.fields.Dict( keys=ma.fields.String(), values=ma.fields.Raw(), @@ -51,7 +46,4 @@ class SampleListResponseSchema(BaseSchema): class RunSamplesQuerySchema(CursorPaginationQuerySchema): """Query parameters for GET /runs/{uuid}/samples.""" - has_profile = ma.fields.Boolean( - load_default=None, - metadata={'description': 'If true, only return samples with profiles'}, - ) + pass diff --git a/tests/server/api/v5/test_agents.py b/tests/server/api/v5/test_agents.py index b491f2ec4..927d4c490 100644 --- a/tests/server/api/v5/test_agents.py +++ b/tests/server/api/v5/test_agents.py @@ -2,7 +2,7 @@ # # RUN: rm -rf %t.instance %t.pg.log # RUN: %{utils}/with_postgres.sh %t.pg.log \ -# RUN: %{utils}/with_temporary_instance.py %t.instance \ +# RUN: %{utils}/with_temporary_instance.py --db-version 5.0 %t.instance \ # RUN: -- python %s %t.instance # END. diff --git a/tests/server/api/v5/test_discovery.py b/tests/server/api/v5/test_discovery.py index dd319733d..7cf33a8eb 100644 --- a/tests/server/api/v5/test_discovery.py +++ b/tests/server/api/v5/test_discovery.py @@ -2,7 +2,7 @@ # # RUN: rm -rf %t.instance %t.pg.log # RUN: %{utils}/with_postgres.sh %t.pg.log \ -# RUN: %{utils}/with_temporary_instance.py %t.instance \ +# RUN: %{utils}/with_temporary_instance.py --db-version 5.0 %t.instance \ # RUN: -- python %s %t.instance # END. @@ -45,7 +45,7 @@ def test_discovery_suite_links_are_complete(self): suite = data['test_suites'][0] links = suite['links'] expected_keys = { - 'machines', 'orders', 'runs', 'tests', + 'machines', 'commits', 'runs', 'tests', 'regressions', 'field_changes', 'query' } self.assertEqual(set(links.keys()), expected_keys) diff --git a/tests/server/api/v5/test_samples.py b/tests/server/api/v5/test_samples.py index 1fb2c4db6..c82b3cefc 100644 --- a/tests/server/api/v5/test_samples.py +++ b/tests/server/api/v5/test_samples.py @@ -2,76 +2,25 @@ # # RUN: rm -rf %t.instance %t.pg.log # RUN: %{utils}/with_postgres.sh %t.pg.log \ -# RUN: %{utils}/with_temporary_instance.py %t.instance \ +# RUN: %{utils}/with_temporary_instance.py --db-version 5.0 %t.instance \ # RUN: -- python %s %t.instance # END. -import base64 import os -import pickle import sys import unittest import uuid -import zlib sys.path.insert(0, os.path.dirname(__file__)) from v5_test_helpers import ( create_app, create_client, make_scoped_headers, - create_machine, create_order, create_run, create_test, create_sample, + create_machine, create_commit, create_run, create_test, create_sample, collect_all_pages, ) TS = 'nts' PREFIX = f'/api/v5/{TS}' -# Profile data in the ProfileV1 format -SAMPLE_PROFILE_DATA = { - 'counters': {'cycles': 12345.0, 'branch-misses': 200.0}, - 'disassembly-format': 'raw', - 'functions': { - 'main': { - 'counters': {'cycles': 80.0}, - 'data': [ - [0x1000, {'cycles': 50.0}, '\tadd r0, r0, r1'], - ], - }, - }, -} - - -def _make_encoded_profile(profile_data=None): - """Create a base64-encoded profile string suitable for the Profile - constructor.""" - if profile_data is None: - profile_data = SAMPLE_PROFILE_DATA - compressed = zlib.compress(pickle.dumps(profile_data)) - return base64.b64encode(compressed).decode('ascii') - - -class _MockConfig(object): - """Mock config object for Profile.__init__. - - Profile.__init__ accesses config.config.profileDir. - """ - def __init__(self, profile_dir): - self.config = self - self.profileDir = profile_dir - - -def _create_sample_with_profile(session, ts, run, test, profile_dir): - """Create a sample with an associated profile record on disk.""" - encoded = _make_encoded_profile() - config = _MockConfig(profile_dir) - profile_obj = ts.Profile(encoded, config, test.name) - session.add(profile_obj) - session.flush() - - sample = ts.Sample(run, test) - sample.profile_id = profile_obj.id - session.add(sample) - session.flush() - return sample - class TestRunSamples(unittest.TestCase): """Tests for GET /api/v5/{ts}/runs/{uuid}/samples.""" @@ -89,9 +38,9 @@ def _setup_run_with_samples(self): machine = create_machine( session, ts, f'sample-test-machine-{uuid.uuid4().hex[:8]}') - order = create_order( - session, ts, revision=f'sample-rev-{uuid.uuid4().hex[:8]}') - run = create_run(session, ts, machine, order) + commit = create_commit( + session, ts, commit=f'sample-rev-{uuid.uuid4().hex[:8]}') + run = create_run(session, ts, machine, commit) test1 = create_test( session, ts, f'test.suite/bench1-{uuid.uuid4().hex[:8]}') @@ -116,9 +65,9 @@ def test_list_samples_empty_run(self): ts = db.testsuite['nts'] machine = create_machine( session, ts, f'empty-run-machine-{uuid.uuid4().hex[:8]}') - order = create_order( - session, ts, revision=f'empty-rev-{uuid.uuid4().hex[:8]}') - run = create_run(session, ts, machine, order) + commit = create_commit( + session, ts, commit=f'empty-rev-{uuid.uuid4().hex[:8]}') + run = create_run(session, ts, machine, commit) session.commit() run_uuid = run.uuid session.close() @@ -139,11 +88,11 @@ def test_list_samples_with_data(self): self.assertIn('items', data) self.assertGreaterEqual(len(data['items']), 2) - # Verify sample structure + # Verify sample structure (v5: test + metrics, no has_profile) sample = data['items'][0] self.assertIn('test', sample) - self.assertIn('has_profile', sample) self.assertIn('metrics', sample) + self.assertNotIn('has_profile', sample) self.assertIsInstance(sample['metrics'], dict) def test_list_samples_has_pagination(self): @@ -161,61 +110,6 @@ def test_list_samples_nonexistent_run(self): resp = self.client.get(PREFIX + f'/runs/{fake_uuid}/samples') self.assertEqual(resp.status_code, 404) - def test_list_samples_has_profile_filter(self): - """The has_profile=true filter returns only profiled samples.""" - db = self.app.instance.get_database("default") - session = db.make_session() - ts = db.testsuite['nts'] - - machine = create_machine( - session, ts, f'profile-filter-machine-{uuid.uuid4().hex[:8]}') - order = create_order( - session, ts, revision=f'pf-rev-{uuid.uuid4().hex[:8]}') - run = create_run(session, ts, machine, order) - - test_no_profile = create_test( - session, ts, - f'test.suite/no-profile-{uuid.uuid4().hex[:8]}') - test_with_profile = create_test( - session, ts, - f'test.suite/with-profile-{uuid.uuid4().hex[:8]}') - - # Sample without profile - create_sample(session, ts, run, test_no_profile) - - # Sample with profile - profile_dir = self.app.old_config.profileDir - _create_sample_with_profile( - session, ts, run, test_with_profile, profile_dir) - - session.commit() - run_uuid = run.uuid - session.close() - - # Without filter: should return both - resp = self.client.get(PREFIX + f'/runs/{run_uuid}/samples') - self.assertEqual(resp.status_code, 200) - all_items = resp.get_json()['items'] - self.assertGreaterEqual(len(all_items), 2) - - # With filter: should return only the one with profile - resp = self.client.get( - PREFIX + f'/runs/{run_uuid}/samples?has_profile=true') - self.assertEqual(resp.status_code, 200) - profiled_items = resp.get_json()['items'] - self.assertGreaterEqual(len(profiled_items), 1) - for item in profiled_items: - self.assertTrue(item['has_profile']) - - def test_list_samples_has_profile_false_returns_all(self): - """has_profile with a non-true value does not filter.""" - run_uuid, _, _ = self._setup_run_with_samples() - resp = self.client.get( - PREFIX + f'/runs/{run_uuid}/samples?has_profile=false') - self.assertEqual(resp.status_code, 200) - data = resp.get_json() - self.assertIn('items', data) - def test_invalid_cursor_returns_400(self): """An invalid cursor string should return 400.""" run_uuid, _, _ = self._setup_run_with_samples() @@ -240,9 +134,9 @@ def _setup_run_with_samples(self): machine = create_machine( session, ts, f'test-sample-machine-{uuid.uuid4().hex[:8]}') - order = create_order( - session, ts, revision=f'ts-rev-{uuid.uuid4().hex[:8]}') - run = create_run(session, ts, machine, order) + commit = create_commit( + session, ts, commit=f'ts-rev-{uuid.uuid4().hex[:8]}') + run = create_run(session, ts, machine, commit) test = create_test( session, ts, f'test.suite/specific-{uuid.uuid4().hex[:8]}') @@ -281,9 +175,9 @@ def test_samples_for_nonexistent_test(self): ts = db.testsuite['nts'] machine = create_machine( session, ts, f'nonexist-test-machine-{uuid.uuid4().hex[:8]}') - order = create_order( - session, ts, revision=f'ne-rev-{uuid.uuid4().hex[:8]}') - run = create_run(session, ts, machine, order) + commit = create_commit( + session, ts, commit=f'ne-rev-{uuid.uuid4().hex[:8]}') + run = create_run(session, ts, machine, commit) session.commit() run_uuid = run.uuid session.close() @@ -300,9 +194,9 @@ def test_samples_test_name_with_slashes(self): machine = create_machine( session, ts, f'slash-machine-{uuid.uuid4().hex[:8]}') - order = create_order( - session, ts, revision=f'sl-rev-{uuid.uuid4().hex[:8]}') - run = create_run(session, ts, machine, order) + commit = create_commit( + session, ts, commit=f'sl-rev-{uuid.uuid4().hex[:8]}') + run = create_run(session, ts, machine, commit) # Test name with slashes test_name = f'test/suite/sub/bench-{uuid.uuid4().hex[:8]}' @@ -348,9 +242,9 @@ def setUpClass(cls): ts = db.testsuite['nts'] machine = create_machine( session, ts, f'auth-sample-machine-{uuid.uuid4().hex[:8]}') - order = create_order( - session, ts, revision=f'auth-sample-rev-{uuid.uuid4().hex[:8]}') - run = create_run(session, ts, machine, order) + commit = create_commit( + session, ts, commit=f'auth-sample-rev-{uuid.uuid4().hex[:8]}') + run = create_run(session, ts, machine, commit) test = create_test( session, ts, f'test.suite/auth-bench-{uuid.uuid4().hex[:8]}') create_sample(session, ts, run, test) @@ -400,9 +294,9 @@ def setUpClass(cls): ts = db.testsuite['nts'] machine = create_machine( session, ts, f'pag-sample-m-{uuid.uuid4().hex[:8]}') - order = create_order( - session, ts, revision=f'pag-sample-rev-{uuid.uuid4().hex[:8]}') - run = create_run(session, ts, machine, order) + commit = create_commit( + session, ts, commit=f'pag-sample-rev-{uuid.uuid4().hex[:8]}') + run = create_run(session, ts, machine, commit) for i in range(5): test = create_test( session, ts, @@ -440,9 +334,9 @@ def setUpClass(cls): ts = db.testsuite['nts'] machine = create_machine( session, ts, f'unk-sample-machine-{uuid.uuid4().hex[:8]}') - order = create_order( - session, ts, revision=f'unk-sample-rev-{uuid.uuid4().hex[:8]}') - run = create_run(session, ts, machine, order) + commit = create_commit( + session, ts, commit=f'unk-sample-rev-{uuid.uuid4().hex[:8]}') + run = create_run(session, ts, machine, commit) test = create_test( session, ts, f'test.suite/unk-bench-{uuid.uuid4().hex[:8]}') create_sample(session, ts, run, test) diff --git a/tests/server/api/v5/test_tests.py b/tests/server/api/v5/test_tests.py index 05353a5ab..e904f3cb0 100644 --- a/tests/server/api/v5/test_tests.py +++ b/tests/server/api/v5/test_tests.py @@ -2,7 +2,7 @@ # # RUN: rm -rf %t.instance %t.pg.log # RUN: %{utils}/with_postgres.sh %t.pg.log \ -# RUN: %{utils}/with_temporary_instance.py %t.instance \ +# RUN: %{utils}/with_temporary_instance.py --db-version 5.0 %t.instance \ # RUN: -- python %s %t.instance # END. From 72f831eeaa0c6d226728e8195681a73c48ddbc16 Mon Sep 17 00:00:00 2001 From: Louis Dionne Date: Mon, 13 Apr 2026 21:37:24 -0400 Subject: [PATCH 039/143] [API] Rewrite runs endpoint for v5 DB Co-Authored-By: Claude Opus 4.6 (1M context) --- lnt/server/api/v5/endpoints/runs.py | 112 +++----- lnt/server/api/v5/schemas/runs.py | 38 +-- tests/server/api/v5/test_runs.py | 413 +++++++++++++--------------- 3 files changed, 232 insertions(+), 331 deletions(-) diff --git a/lnt/server/api/v5/endpoints/runs.py b/lnt/server/api/v5/endpoints/runs.py index 804d97641..5a5dd4dc6 100644 --- a/lnt/server/api/v5/endpoints/runs.py +++ b/lnt/server/api/v5/endpoints/runs.py @@ -1,15 +1,14 @@ """Run endpoints for the v5 API. GET /api/v5/{ts}/runs -- List runs (cursor-paginated) -POST /api/v5/{ts}/runs -- Submit run (reuses import pipeline) +POST /api/v5/{ts}/runs -- Submit run (v5 format) GET /api/v5/{ts}/runs/{uuid} -- Run detail DELETE /api/v5/{ts}/runs/{uuid} -- Delete run """ import json -import lnt.util.ImportData -from flask import current_app, g, jsonify, make_response, request +from flask import g, jsonify, make_response, request from flask.views import MethodView from flask_smorest import Blueprint from sqlalchemy.orm import joinedload @@ -17,7 +16,7 @@ from ..auth import require_scope from ..errors import abort_with_error, reject_unknown_params from ..etag import add_etag_to_response -from ..helpers import parse_datetime, serialize_run +from ..helpers import lookup_run_by_uuid, parse_datetime, serialize_run from ..pagination import ( cursor_paginate, make_paginated_response, @@ -30,12 +29,6 @@ RunSubmitResponseSchema, ) -# Maps v5 on_machine_conflict values to internal select_machine values. -_CONFLICT_MAP = {'reject': 'match', 'update': 'update'} - -# Maps v5 on_existing_run values to internal merge_run values. -_MERGE_MAP = {'reject': 'reject', 'replace': 'replace', 'create': 'append'} - blp = Blueprint( 'Runs', __name__, @@ -54,37 +47,31 @@ class RunList(MethodView): def get(self, query_args, testsuite): """List runs (cursor-paginated, filterable).""" reject_unknown_params( - {'machine', 'order', 'after', 'before', 'sort', 'cursor', 'limit'}) + {'machine', 'commit', 'after', 'before', 'sort', + 'cursor', 'limit'}) ts = g.ts session = g.db_session query = session.query(ts.Run).options( joinedload(ts.Run.machine), - joinedload(ts.Run.order), + joinedload(ts.Run.commit_obj), ) # Filter by machine name machine_name = query_args.get('machine') if machine_name: - machine = session.query(ts.Machine).filter( - ts.Machine.name == machine_name - ).first() + machine = ts.get_machine(session, name=machine_name) if machine is None: return jsonify(make_paginated_response([], None)) query = query.filter(ts.Run.machine_id == machine.id) - # Filter by order (primary order field value) - order_value = query_args.get('order') - if order_value: - # Look up orders matching the primary field value - primary_field = ts.order_fields[0] - matching_orders = session.query(ts.Order).filter( - primary_field.column == order_value - ).all() - if not matching_orders: + # Filter by commit string + commit_value = query_args.get('commit') + if commit_value: + commit_obj = ts.get_commit(session, commit=commit_value) + if commit_obj is None: return jsonify(make_paginated_response([], None)) - order_ids = [o.id for o in matching_orders] - query = query.filter(ts.Run.order_id.in_(order_ids)) + query = query.filter(ts.Run.commit_id == commit_obj.id) # Filter by after/before datetime after_str = query_args.get('after') @@ -92,18 +79,18 @@ def get(self, query_args, testsuite): after_dt = parse_datetime(after_str) if after_dt is None: abort_with_error(400, "Invalid 'after' datetime format") - query = query.filter(ts.Run.start_time > after_dt) + query = query.filter(ts.Run.submitted_at > after_dt) before_str = query_args.get('before') if before_str: before_dt = parse_datetime(before_str) if before_dt is None: abort_with_error(400, "Invalid 'before' datetime format") - query = query.filter(ts.Run.start_time < before_dt) + query = query.filter(ts.Run.submitted_at < before_dt) # Sort: default is ascending by ID (insertion order). sort = query_args.get('sort') - descending = (sort == '-start_time') + descending = (sort == '-submitted_at') cursor_str = query_args.get('cursor') limit = query_args['limit'] @@ -119,22 +106,19 @@ def get(self, query_args, testsuite): def post(self, query_args, testsuite): """Submit a new run. - Accepts the LNT JSON report format (format_version '2' only). - Legacy formats (v0, v1) and non-JSON payloads (e.g. plist) - are rejected. A UUID is assigned to the run automatically. - + Accepts the v5 JSON report format (format_version '5'). Regression detection is always skipped; create field changes separately via POST /field-changes. """ - reject_unknown_params({'on_machine_conflict', 'on_existing_run'}) - db = g.db + reject_unknown_params({'on_machine_conflict'}) + ts = g.ts session = g.db_session data = request.get_data(as_text=True) if not data or not data.strip(): - abort_with_error(400, "Request body must be a non-empty JSON payload") + abort_with_error(400, + "Request body must be a non-empty JSON payload") - # Mandate JSON format with format_version '2' for the v5 API. try: parsed = json.loads(data) except ValueError as exc: @@ -142,46 +126,25 @@ def post(self, query_args, testsuite): if not isinstance(parsed, dict): abort_with_error(400, "Request body must be a JSON object, " "not %s" % type(parsed).__name__) + version = parsed.get('format_version') if version is None: - abort_with_error(400, "v5 API requires format_version '2', " + abort_with_error(400, "v5 API requires format_version '5', " "but it is missing") - if version != '2': - abort_with_error(400, "v5 API requires format_version '2', " + if version != '5': + abort_with_error(400, "v5 API requires format_version '5', " "got %r" % (version,)) - select_machine = _CONFLICT_MAP[query_args['on_machine_conflict']] - merge_run = _MERGE_MAP[query_args['on_existing_run']] - - result = lnt.util.ImportData.import_from_string( - current_app.old_config, g.db_name, db, session, - testsuite, data, - select_machine=select_machine, - merge_run=merge_run, - ignore_regressions=True, - ) - - error = result.get('error') - if error is not None: - abort_with_error(400, str(error)) - - # The import pipeline assigned a UUID in _getOrCreateRun(). - # Retrieve the run to get its UUID. - run_id = result.get('run_id') - if run_id is None: - abort_with_error(500, "Import succeeded but no run_id returned") - - # Re-query to get the UUID (the session may have committed already). - ts = db.testsuite.get(testsuite) - if ts is None: - abort_with_error(500, "Testsuite not found after import") + try: + run = ts.import_run( + session, parsed, + machine_strategy=query_args['on_machine_conflict']) + except ValueError as exc: + abort_with_error(400, str(exc)) - run = session.query(ts.Run).filter(ts.Run.id == run_id).first() - if run is None: - abort_with_error(500, "Run not found after import") + session.flush() run_uuid = run.uuid - result_url = '/api/v5/%s/runs/%s' % (testsuite, run_uuid) response = jsonify({ @@ -208,7 +171,7 @@ def get(self, testsuite, run_uuid): run = session.query(ts.Run).options( joinedload(ts.Run.machine), - joinedload(ts.Run.order), + joinedload(ts.Run.commit_obj), ).filter(ts.Run.uuid == run_uuid).first() if run is None: @@ -224,14 +187,9 @@ def delete(self, testsuite, run_uuid): ts = g.ts session = g.db_session - run = session.query(ts.Run).filter( - ts.Run.uuid == run_uuid - ).first() - - if run is None: - abort_with_error(404, "Run '%s' not found" % run_uuid) + run = lookup_run_by_uuid(session, ts, run_uuid) - session.delete(run) + ts.delete_run(session, run.id) session.flush() return make_response('', 204) diff --git a/lnt/server/api/v5/schemas/runs.py b/lnt/server/api/v5/schemas/runs.py index 44f8462ad..75ebf1731 100644 --- a/lnt/server/api/v5/schemas/runs.py +++ b/lnt/server/api/v5/schemas/runs.py @@ -20,25 +20,20 @@ class RunResponseSchema(BaseSchema): required=True, metadata={'description': 'Name of the machine this run was on'}, ) - order = ma.fields.Dict( - keys=ma.fields.String(), - values=ma.fields.String(), + commit = ma.fields.String( + allow_none=True, metadata={ - 'description': 'Order field values (e.g. revision)', - 'example': {'llvm_project_revision': 'abc123'}, + 'description': 'Commit string for this run', + 'example': 'abc123def456', }, ) - start_time = ma.fields.String( - allow_none=True, - metadata={'description': 'Run start time (ISO 8601)'}, - ) - end_time = ma.fields.String( + submitted_at = ma.fields.String( allow_none=True, - metadata={'description': 'Run end time (ISO 8601)'}, + metadata={'description': 'Run submission time (ISO 8601)'}, ) - parameters = ma.fields.Dict( + run_parameters = ma.fields.Dict( keys=ma.fields.String(), - values=ma.fields.String(), + values=ma.fields.Raw(), load_default=None, metadata={ 'description': 'Additional run parameters', @@ -78,21 +73,21 @@ class RunListQuerySchema(CursorPaginationQuerySchema): load_default=None, metadata={'description': 'Filter by machine name'}, ) - order = ma.fields.String( + commit = ma.fields.String( load_default=None, - metadata={'description': 'Filter by primary order field value'}, + metadata={'description': 'Filter by commit string'}, ) after = ma.fields.String( load_default=None, - metadata={'description': 'ISO datetime, only runs started after this time'}, + metadata={'description': 'ISO datetime, only runs submitted after this time'}, ) before = ma.fields.String( load_default=None, - metadata={'description': 'ISO datetime, only runs started before this time'}, + metadata={'description': 'ISO datetime, only runs submitted before this time'}, ) sort = ma.fields.String( load_default=None, - metadata={'description': 'Sort order. Use -start_time for newest first'}, + metadata={'description': 'Sort order. Use -submitted_at for newest first'}, ) @@ -104,10 +99,3 @@ class RunSubmitQuerySchema(BaseQuerySchema): metadata={'description': "What to do when machine metadata differs: " "'reject' aborts, 'update' updates the existing machine"}, ) - on_existing_run = ma.fields.String( - load_default='reject', - validate=ma.validate.OneOf(['reject', 'replace', 'create']), - metadata={'description': "What to do when a run already exists for " - "this machine+order: 'reject' aborts, 'replace' overwrites " - "the existing run, 'create' creates a new run alongside it"}, - ) diff --git a/tests/server/api/v5/test_runs.py b/tests/server/api/v5/test_runs.py index ad7ad7b7d..7002af7ff 100644 --- a/tests/server/api/v5/test_runs.py +++ b/tests/server/api/v5/test_runs.py @@ -2,10 +2,11 @@ # # RUN: rm -rf %t.instance %t.pg.log # RUN: %{utils}/with_postgres.sh %t.pg.log \ -# RUN: %{utils}/with_temporary_instance.py %t.instance \ +# RUN: %{utils}/with_temporary_instance.py --db-version 5.0 %t.instance \ # RUN: -- python %s %t.instance # END. +import datetime import json import sys import os @@ -15,6 +16,7 @@ sys.path.insert(0, os.path.dirname(__file__)) from v5_test_helpers import ( create_app, create_client, admin_headers, make_scoped_headers, + create_machine, create_commit, create_run, collect_all_pages, submit_run, ) @@ -23,32 +25,23 @@ PREFIX = f'/api/v5/{TS}' -def _make_submission_payload(machine_name=None, revision=None, - start_time=None, end_time=None): - """Build a valid v2-format JSON submission payload.""" +def _make_submission_payload(machine_name=None, commit_str=None): + """Build a valid v5-format JSON submission payload.""" if machine_name is None: machine_name = f'submit-machine-{uuid.uuid4().hex[:8]}' - if revision is None: - revision = f'r{uuid.uuid4().hex[:8]}' - if start_time is None: - start_time = '2024-06-15T10:00:00' - if end_time is None: - end_time = '2024-06-15T10:30:00' + if commit_str is None: + commit_str = f'r{uuid.uuid4().hex[:8]}' return json.dumps({ - 'format_version': '2', + 'format_version': '5', 'machine': { 'name': machine_name, }, - 'run': { - 'start_time': start_time, - 'end_time': end_time, - 'llvm_project_revision': revision, - }, + 'commit': commit_str, 'tests': [ { 'name': 'test.suite/benchmark1', - 'execution_time': [0.1234, 0.1235], + 'execution_time': 0.1234, }, ], }) @@ -93,7 +86,7 @@ def test_list_includes_created_runs(self): name = f'list-data-{uuid.uuid4().hex[:8]}' rev = f'list-rev-{uuid.uuid4().hex[:6]}' data = submit_run(self.client, name, rev, - [{'name': 'p/test', 'execution_time': [0.0]}]) + [{'name': 'p/test', 'execution_time': 0.0}]) run_uuid = data['run_uuid'] resp = self.client.get(PREFIX + f'/runs?machine={name}') @@ -102,10 +95,10 @@ def test_list_includes_created_runs(self): self.assertIn(run_uuid, uuids) def test_list_run_has_expected_fields(self): - """Each run in the list has uuid, machine_name, order, start_time, end_time.""" + """Each run in the list has uuid, machine, commit, submitted_at, run_parameters.""" name = f'list-fields-{uuid.uuid4().hex[:8]}' submit_run(self.client, name, f'fields-rev-{uuid.uuid4().hex[:6]}', - [{'name': 'p/test', 'execution_time': [0.0]}]) + [{'name': 'p/test', 'execution_time': 0.0}]) resp = self.client.get(PREFIX + f'/runs?machine={name}') data = resp.get_json() @@ -113,25 +106,29 @@ def test_list_run_has_expected_fields(self): item = data['items'][0] self.assertIn('uuid', item) self.assertIn('machine', item) - self.assertIn('order', item) - self.assertIn('start_time', item) - self.assertIn('end_time', item) - # Must NOT have internal IDs + self.assertIn('commit', item) + self.assertIn('submitted_at', item) + self.assertIn('run_parameters', item) + # Must NOT have internal IDs or v4 fields self.assertNotIn('id', item) self.assertNotIn('machine_id', item) + self.assertNotIn('order', item) + self.assertNotIn('start_time', item) + self.assertNotIn('end_time', item) + self.assertNotIn('parameters', item) def test_list_never_exposes_internal_ids(self): """Run list items never contain internal database IDs.""" name = f'no-ids-{uuid.uuid4().hex[:8]}' submit_run(self.client, name, f'noid-rev-{uuid.uuid4().hex[:6]}', - [{'name': 'p/test', 'execution_time': [0.0]}]) + [{'name': 'p/test', 'execution_time': 0.0}]) resp = self.client.get(PREFIX + f'/runs?machine={name}') data = resp.get_json() for item in data['items']: self.assertNotIn('id', item) self.assertNotIn('machine_id', item) - self.assertNotIn('order_id', item) + self.assertNotIn('commit_id', item) class TestRunListPagination(unittest.TestCase): @@ -148,9 +145,7 @@ def test_pagination(self): for i in range(3): submit_run(self.client, name, f'page-rev-{uuid.uuid4().hex[:6]}-{i}', - [{'name': 'p/test', 'execution_time': [0.0]}], - start_time=f'2024-01-0{1 + i}T12:00:00', - end_time=f'2024-01-0{1 + i}T13:00:00') + [{'name': 'p/test', 'execution_time': 0.0}]) # Get first page with limit=2 resp = self.client.get(PREFIX + f'/runs?machine={name}&limit=2') @@ -186,8 +181,7 @@ def test_submit_valid_payload(self): content_type='application/json', headers=admin_headers(), ) - # The import pipeline returns 201 on success - self.assertIn(resp.status_code, [201, 301]) + self.assertEqual(resp.status_code, 201) data = resp.get_json() self.assertTrue(data.get('success')) self.assertIn('run_uuid', data) @@ -304,7 +298,7 @@ def test_submit_with_submit_scope_succeeds(self): content_type='application/json', headers=headers, ) - self.assertIn(resp.status_code, [201, 301]) + self.assertEqual(resp.status_code, 201) def test_submit_result_url_format(self): """Result URL should point to the v5 run detail.""" @@ -322,7 +316,7 @@ def test_submit_result_url_format(self): class TestRunSubmitFormatValidation(unittest.TestCase): - """Tests that POST /api/v5/{ts}/runs mandates JSON format_version '2'.""" + """Tests that POST /api/v5/{ts}/runs mandates format_version '5'.""" @classmethod def setUpClass(cls): super().setUpClass() @@ -355,8 +349,7 @@ def test_submit_missing_format_version_400(self): """A JSON object without format_version returns 400.""" payload = json.dumps({ 'machine': {'name': 'dummy'}, - 'run': {'start_time': '2024-01-01', 'end_time': '2024-01-01', - 'llvm_project_revision': 'rev1'}, + 'commit': 'rev1', 'tests': [], }) resp = self.client.post( @@ -371,12 +364,11 @@ def test_submit_missing_format_version_400(self): self.assertIn('missing', msg) def test_submit_wrong_format_version_400(self): - """format_version '1' is rejected.""" + """format_version '2' (v4 format) is rejected.""" payload = json.dumps({ - 'format_version': '1', + 'format_version': '2', 'machine': {'name': 'dummy'}, - 'run': {'start_time': '2024-01-01', 'end_time': '2024-01-01', - 'llvm_project_revision': 'rev1'}, + 'commit': 'rev1', 'tests': [], }) resp = self.client.post( @@ -390,12 +382,11 @@ def test_submit_wrong_format_version_400(self): self.assertIn('format_version', msg) def test_submit_integer_format_version_400(self): - """format_version as integer 2 (not string '2') is rejected.""" + """format_version as integer 5 (not string '5') is rejected.""" payload = json.dumps({ - 'format_version': 2, + 'format_version': 5, 'machine': {'name': 'dummy'}, - 'run': {'start_time': '2024-01-01', 'end_time': '2024-01-01', - 'llvm_project_revision': 'rev1'}, + 'commit': 'rev1', 'tests': [], }) resp = self.client.post( @@ -408,8 +399,8 @@ def test_submit_integer_format_version_400(self): msg = resp.get_json()['error']['message'] self.assertIn('format_version', msg) - def test_submit_v2_format_accepted(self): - """A valid format_version '2' payload is accepted.""" + def test_submit_v5_format_accepted(self): + """A valid format_version '5' payload is accepted.""" payload = _make_submission_payload() resp = self.client.post( PREFIX + '/runs', @@ -475,34 +466,31 @@ def test_invalid_value_returns_422(self): self.assertEqual(resp.status_code, 422) -def _make_submission_with_info(machine_name, machine_info, revision=None): - """Build a v2-format JSON submission payload with machine info fields.""" - if revision is None: - revision = f'r{uuid.uuid4().hex[:8]}' +def _make_submission_with_info(machine_name, machine_info, commit_str=None): + """Build a v5-format JSON submission payload with machine info fields.""" + if commit_str is None: + commit_str = f'r{uuid.uuid4().hex[:8]}' machine = {'name': machine_name} machine.update(machine_info) return json.dumps({ - 'format_version': '2', + 'format_version': '5', 'machine': machine, - 'run': { - 'start_time': '2024-06-15T10:00:00', - 'end_time': '2024-06-15T10:30:00', - 'llvm_project_revision': revision, - }, + 'commit': commit_str, 'tests': [ { 'name': 'test.suite/benchmark1', - 'execution_time': [0.1234], + 'execution_time': 0.1234, }, ], }) class TestMachineConflictUpdateBehavior(unittest.TestCase): - """Behavioral tests for on_machine_conflict=update on POST /runs. + """Behavioral tests for on_machine_conflict on POST /runs. - These tests verify that the 'update' strategy actually modifies - the existing machine's info rather than creating a duplicate. + These tests verify that the 'reject' strategy raises on + machine field conflicts, and that the 'update' strategy does not + create duplicates. """ @classmethod def setUpClass(cls): @@ -523,20 +511,20 @@ def _submit_run(self, machine_name, machine_info, conflict='update'): headers=admin_headers(), ) - def _get_machine(self, machine_name): - """Helper: GET a machine by name and return (status_code, json).""" - resp = self.client.get(PREFIX + f'/machines/{machine_name}') - return resp.status_code, resp.get_json() - def _list_machines_by_name(self, machine_name): """Helper: list machines filtered by exact name prefix.""" resp = self.client.get( - PREFIX + f'/machines?name_prefix={machine_name}') + PREFIX + f'/machines?search={machine_name}') self.assertEqual(resp.status_code, 200) data = resp.get_json() - # Filter to exact name matches (name_prefix could match longer names) + # Filter to exact name matches (search could match longer names) return [m for m in data['items'] if m['name'] == machine_name] + def _get_machine(self, machine_name): + """Helper: GET a machine by name and return (status_code, json).""" + resp = self.client.get(PREFIX + f'/machines/{machine_name}') + return resp.status_code, resp.get_json() + def test_update_does_not_create_new_machine(self): """on_machine_conflict=update reuses the existing machine, no duplicate.""" name = f'mc-update-nodup-{uuid.uuid4().hex[:8]}' @@ -580,11 +568,11 @@ def test_reject_default_raises_on_conflict(self): """Default reject mode returns 400 when machine info has changed.""" name = f'mc-reject-err-{uuid.uuid4().hex[:8]}' - # First submission creates the machine. + # First submission creates the machine with os=Linux. resp1 = self._submit_run(name, {'os': 'Linux'}, conflict=None) self.assertEqual(resp1.status_code, 201) - # Second submission with different info and default (reject) mode. + # Second submission with different os and default (reject) mode. resp2 = self._submit_run(name, {'os': 'Linux-v2'}, conflict=None) self.assertEqual(resp2.status_code, 400) @@ -608,90 +596,25 @@ def test_update_preserves_existing_fields_when_new_is_null(self): """on_machine_conflict=update preserves fields not in the new submission.""" name = f'mc-update-preserve-{uuid.uuid4().hex[:8]}' - # First submission with both os and arch. - resp1 = self._submit_run(name, {'os': 'Linux', 'arch': 'x86_64'}) + # First submission with both os and hardware. + resp1 = self._submit_run(name, {'os': 'Linux', 'hardware': 'x86_64'}) self.assertEqual(resp1.status_code, 201) # Verify both fields are set. status, data = self._get_machine(name) self.assertEqual(status, 200) self.assertEqual(data['info']['os'], 'Linux') - self.assertEqual(data['info']['arch'], 'x86_64') + self.assertEqual(data['info']['hardware'], 'x86_64') - # Second submission with only os (no arch). + # Second submission with only os (no hardware). resp2 = self._submit_run(name, {'os': 'Linux-v2'}, conflict='update') self.assertEqual(resp2.status_code, 201) - # Verify os is updated but arch is preserved. + # Verify os is updated but hardware is preserved. status, data = self._get_machine(name) self.assertEqual(status, 200) self.assertEqual(data['info']['os'], 'Linux-v2') - self.assertEqual(data['info']['arch'], 'x86_64') - - -class TestRunSubmitOnExistingRun(unittest.TestCase): - """Tests for the on_existing_run query parameter on POST /runs.""" - @classmethod - def setUpClass(cls): - super().setUpClass() - cls.app = create_app(sys.argv[1]) - cls.client = create_client(cls.app) - - def test_default_is_reject(self): - """Omitting on_existing_run uses reject by default.""" - payload = _make_submission_payload() - resp = self.client.post( - PREFIX + '/runs', - data=payload, - content_type='application/json', - headers=admin_headers(), - ) - self.assertEqual(resp.status_code, 201) - self.assertTrue(resp.get_json().get('success')) - - def test_reject_value_accepted(self): - """on_existing_run=reject is accepted.""" - payload = _make_submission_payload() - resp = self.client.post( - PREFIX + '/runs?on_existing_run=reject', - data=payload, - content_type='application/json', - headers=admin_headers(), - ) - self.assertEqual(resp.status_code, 201) - - def test_replace_value_accepted(self): - """on_existing_run=replace is accepted.""" - payload = _make_submission_payload() - resp = self.client.post( - PREFIX + '/runs?on_existing_run=replace', - data=payload, - content_type='application/json', - headers=admin_headers(), - ) - self.assertEqual(resp.status_code, 201) - - def test_create_value_accepted(self): - """on_existing_run=create is accepted.""" - payload = _make_submission_payload() - resp = self.client.post( - PREFIX + '/runs?on_existing_run=create', - data=payload, - content_type='application/json', - headers=admin_headers(), - ) - self.assertEqual(resp.status_code, 201) - - def test_invalid_value_returns_422(self): - """An invalid on_existing_run value returns 422.""" - payload = _make_submission_payload() - resp = self.client.post( - PREFIX + '/runs?on_existing_run=bogus', - data=payload, - content_type='application/json', - headers=admin_headers(), - ) - self.assertEqual(resp.status_code, 422) + self.assertEqual(data['info']['hardware'], 'x86_64') class TestRunDetail(unittest.TestCase): @@ -706,7 +629,7 @@ def test_get_run_detail(self): """Get run detail by UUID.""" name = f'detail-{uuid.uuid4().hex[:8]}' data = submit_run(self.client, name, f'detail-rev-{uuid.uuid4().hex[:6]}', - [{'name': 'p/test', 'execution_time': [0.0]}]) + [{'name': 'p/test', 'execution_time': 0.0}]) run_uuid = data['run_uuid'] resp = self.client.get(PREFIX + f'/runs/{run_uuid}') @@ -714,23 +637,22 @@ def test_get_run_detail(self): data = resp.get_json() self.assertEqual(data['uuid'], run_uuid) self.assertEqual(data['machine'], name) - self.assertIn('order', data) - self.assertIn('start_time', data) - self.assertIn('end_time', data) - self.assertIn('parameters', data) + self.assertIn('commit', data) + self.assertIn('submitted_at', data) + self.assertIn('run_parameters', data) def test_get_run_detail_has_no_internal_ids(self): """Run detail does not expose internal IDs.""" name = f'detail-noid-{uuid.uuid4().hex[:8]}' data = submit_run(self.client, name, f'noid-detail-rev-{uuid.uuid4().hex[:6]}', - [{'name': 'p/test', 'execution_time': [0.0]}]) + [{'name': 'p/test', 'execution_time': 0.0}]) run_uuid = data['run_uuid'] resp = self.client.get(PREFIX + f'/runs/{run_uuid}') data = resp.get_json() self.assertNotIn('id', data) self.assertNotIn('machine_id', data) - self.assertNotIn('order_id', data) + self.assertNotIn('commit_id', data) def test_get_nonexistent_uuid_404(self): """Getting a run with a nonexistent UUID returns 404.""" @@ -756,7 +678,7 @@ def test_etag_present_on_detail(self): """Run detail response should include an ETag header.""" name = f'etag-present-{uuid.uuid4().hex[:8]}' data = submit_run(self.client, name, f'etag-rev-{uuid.uuid4().hex[:6]}', - [{'name': 'p/test', 'execution_time': [0.0]}]) + [{'name': 'p/test', 'execution_time': 0.0}]) run_uuid = data['run_uuid'] resp = self.client.get(PREFIX + f'/runs/{run_uuid}') @@ -769,7 +691,7 @@ def test_etag_304_on_match(self): """Sending If-None-Match with the same ETag returns 304.""" name = f'etag-304-{uuid.uuid4().hex[:8]}' data = submit_run(self.client, name, f'etag-304-rev-{uuid.uuid4().hex[:6]}', - [{'name': 'p/test', 'execution_time': [0.0]}]) + [{'name': 'p/test', 'execution_time': 0.0}]) run_uuid = data['run_uuid'] resp = self.client.get(PREFIX + f'/runs/{run_uuid}') @@ -785,7 +707,7 @@ def test_etag_200_on_mismatch(self): """Sending If-None-Match with a different ETag returns 200.""" name = f'etag-200-{uuid.uuid4().hex[:8]}' data = submit_run(self.client, name, f'etag-200-rev-{uuid.uuid4().hex[:6]}', - [{'name': 'p/test', 'execution_time': [0.0]}]) + [{'name': 'p/test', 'execution_time': 0.0}]) run_uuid = data['run_uuid'] resp = self.client.get( @@ -808,7 +730,7 @@ def test_delete_run(self): """Delete a run and verify 204, then verify it's gone.""" name = f'delete-{uuid.uuid4().hex[:8]}' data = submit_run(self.client, name, f'del-rev-{uuid.uuid4().hex[:6]}', - [{'name': 'p/test', 'execution_time': [0.0]}]) + [{'name': 'p/test', 'execution_time': 0.0}]) run_uuid = data['run_uuid'] resp = self.client.delete( @@ -834,7 +756,7 @@ def test_delete_no_auth_401(self): """Deleting without auth returns 401.""" name = f'del-noauth-{uuid.uuid4().hex[:8]}' data = submit_run(self.client, name, f'del-noauth-{uuid.uuid4().hex[:6]}', - [{'name': 'p/test', 'execution_time': [0.0]}]) + [{'name': 'p/test', 'execution_time': 0.0}]) run_uuid = data['run_uuid'] resp = self.client.delete(PREFIX + f'/runs/{run_uuid}') @@ -844,7 +766,7 @@ def test_delete_without_manage_scope_403(self): """Deleting with submit scope (not manage) returns 403.""" name = f'del-scope-{uuid.uuid4().hex[:8]}' data = submit_run(self.client, name, f'del-scope-{uuid.uuid4().hex[:6]}', - [{'name': 'p/test', 'execution_time': [0.0]}]) + [{'name': 'p/test', 'execution_time': 0.0}]) run_uuid = data['run_uuid'] headers = make_scoped_headers(self.app, 'submit') @@ -867,7 +789,7 @@ def test_filter_by_machine_name(self): """Filter runs by machine name.""" name = f'filter-machine-{uuid.uuid4().hex[:8]}' submit_run(self.client, name, f'fm-rev-{uuid.uuid4().hex[:6]}', - [{'name': 'p/test', 'execution_time': [0.0]}]) + [{'name': 'p/test', 'execution_time': 0.0}]) resp = self.client.get(PREFIX + f'/runs?machine={name}') self.assertEqual(resp.status_code, 200) @@ -885,8 +807,46 @@ def test_filter_by_nonexistent_machine(self): self.assertEqual(len(data['items']), 0) +class TestRunFilterByCommit(unittest.TestCase): + """Test filtering runs by commit string.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_filter_by_commit(self): + """Filter runs by commit string.""" + name = f'commit-filter-{uuid.uuid4().hex[:8]}' + rev1 = f'cfilt-rev1-{uuid.uuid4().hex[:6]}' + rev2 = f'cfilt-rev2-{uuid.uuid4().hex[:6]}' + submit_run(self.client, name, rev1, + [{'name': 'p/test', 'execution_time': 0.0}]) + submit_run(self.client, name, rev2, + [{'name': 'p/test', 'execution_time': 0.0}]) + + resp = self.client.get( + PREFIX + f'/runs?machine={name}&commit={rev1}') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertEqual(len(data['items']), 1) + self.assertEqual(data['items'][0]['commit'], rev1) + + def test_filter_by_nonexistent_commit(self): + """Filtering by a nonexistent commit returns empty results.""" + resp = self.client.get( + PREFIX + '/runs?commit=nonexistent-commit-xyz-abc') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertEqual(len(data['items']), 0) + + class TestRunFilterByDatetime(unittest.TestCase): - """Test filtering runs by after/before datetime.""" + """Test filtering runs by after/before datetime (submitted_at). + + Since submitted_at is set server-side, we use direct DB helpers + to create runs with specific timestamps. + """ @classmethod def setUpClass(cls): super().setUpClass() @@ -894,16 +854,24 @@ def setUpClass(cls): cls.client = create_client(cls.app) def test_filter_after(self): - """Filter runs started after a given datetime.""" + """Filter runs submitted after a given datetime.""" name = f'after-{uuid.uuid4().hex[:8]}' - submit_run(self.client, name, f'after-rev1-{uuid.uuid4().hex[:6]}', - [{'name': 'p/test', 'execution_time': [0.0]}], - start_time='2024-01-01T12:00:00', - end_time='2024-01-01T13:00:00') - submit_run(self.client, name, f'after-rev2-{uuid.uuid4().hex[:6]}', - [{'name': 'p/test', 'execution_time': [0.0]}], - start_time='2024-06-01T12:00:00', - end_time='2024-06-01T13:00:00') + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + machine = create_machine(session, ts, name=name) + c1 = create_commit( + session, ts, + commit=f'after-rev1-{uuid.uuid4().hex[:6]}') + create_run(session, ts, machine, c1, + submitted_at=datetime.datetime(2024, 1, 1, 12, 0, 0)) + c2 = create_commit( + session, ts, + commit=f'after-rev2-{uuid.uuid4().hex[:6]}') + create_run(session, ts, machine, c2, + submitted_at=datetime.datetime(2024, 6, 1, 12, 0, 0)) + session.commit() + session.close() resp = self.client.get( PREFIX + f'/runs?machine={name}&after=2024-03-01T00:00:00') @@ -912,16 +880,24 @@ def test_filter_after(self): self.assertEqual(len(data['items']), 1) def test_filter_before(self): - """Filter runs started before a given datetime.""" + """Filter runs submitted before a given datetime.""" name = f'before-{uuid.uuid4().hex[:8]}' - submit_run(self.client, name, f'before-rev1-{uuid.uuid4().hex[:6]}', - [{'name': 'p/test', 'execution_time': [0.0]}], - start_time='2024-01-01T12:00:00', - end_time='2024-01-01T13:00:00') - submit_run(self.client, name, f'before-rev2-{uuid.uuid4().hex[:6]}', - [{'name': 'p/test', 'execution_time': [0.0]}], - start_time='2024-06-01T12:00:00', - end_time='2024-06-01T13:00:00') + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + machine = create_machine(session, ts, name=name) + c1 = create_commit( + session, ts, + commit=f'before-rev1-{uuid.uuid4().hex[:6]}') + create_run(session, ts, machine, c1, + submitted_at=datetime.datetime(2024, 1, 1, 12, 0, 0)) + c2 = create_commit( + session, ts, + commit=f'before-rev2-{uuid.uuid4().hex[:6]}') + create_run(session, ts, machine, c2, + submitted_at=datetime.datetime(2024, 6, 1, 12, 0, 0)) + session.commit() + session.close() resp = self.client.get( PREFIX + f'/runs?machine={name}&before=2024-03-01T00:00:00') @@ -932,12 +908,19 @@ def test_filter_before(self): def test_filter_after_and_before(self): """Filter runs within a datetime range.""" name = f'range-{uuid.uuid4().hex[:8]}' + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + machine = create_machine(session, ts, name=name) for month in (1, 4, 7, 10): - submit_run(self.client, name, - f'range-rev-{month}-{uuid.uuid4().hex[:6]}', - [{'name': 'p/test', 'execution_time': [0.0]}], - start_time=f'2024-{month:02d}-15T12:00:00', - end_time=f'2024-{month:02d}-15T13:00:00') + c = create_commit( + session, ts, + commit=f'range-rev-{month}-{uuid.uuid4().hex[:6]}') + create_run(session, ts, machine, c, + submitted_at=datetime.datetime( + 2024, month, 15, 12, 0, 0)) + session.commit() + session.close() resp = self.client.get( PREFIX + f'/runs?machine={name}&after=2024-03-01T00:00:00&before=2024-08-01T00:00:00') @@ -957,40 +940,6 @@ def test_filter_invalid_before_datetime_400(self): self.assertEqual(resp.status_code, 400) -class TestRunFilterByOrder(unittest.TestCase): - """Test filtering runs by order (primary order field value).""" - @classmethod - def setUpClass(cls): - super().setUpClass() - cls.app = create_app(sys.argv[1]) - cls.client = create_client(cls.app) - - def test_filter_by_order_value(self): - """Filter runs by primary order field value.""" - name = f'order-filter-{uuid.uuid4().hex[:8]}' - rev1 = f'ofilt-rev1-{uuid.uuid4().hex[:6]}' - rev2 = f'ofilt-rev2-{uuid.uuid4().hex[:6]}' - submit_run(self.client, name, rev1, - [{'name': 'p/test', 'execution_time': [0.0]}]) - submit_run(self.client, name, rev2, - [{'name': 'p/test', 'execution_time': [0.0]}]) - - resp = self.client.get( - PREFIX + f'/runs?machine={name}&order={rev1}') - self.assertEqual(resp.status_code, 200) - data = resp.get_json() - self.assertEqual(len(data['items']), 1) - self.assertIn(rev1, data['items'][0]['order'].values()) - - def test_filter_by_nonexistent_order(self): - """Filtering by a nonexistent order returns empty results.""" - resp = self.client.get( - PREFIX + '/runs?order=nonexistent-revision-xyz-abc') - self.assertEqual(resp.status_code, 200) - data = resp.get_json() - self.assertEqual(len(data['items']), 0) - - class TestRunSort(unittest.TestCase): """Test sorting runs.""" @classmethod @@ -999,29 +948,38 @@ def setUpClass(cls): cls.app = create_app(sys.argv[1]) cls.client = create_client(cls.app) - def test_sort_descending_start_time(self): - """Sort runs by -start_time returns newest first.""" + def test_sort_descending_submitted_at(self): + """Sort runs by -submitted_at returns newest first.""" name = f'sort-run-{uuid.uuid4().hex[:8]}' + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + machine = create_machine(session, ts, name=name) for month in (1, 4, 7): - submit_run(self.client, name, - f'sort-rev-{month}-{uuid.uuid4().hex[:6]}', - [{'name': 'p/test', 'execution_time': [0.0]}], - start_time=f'2024-{month:02d}-01T12:00:00', - end_time=f'2024-{month:02d}-01T13:00:00') + c = create_commit( + session, ts, + commit=f'sort-rev-{month}-{uuid.uuid4().hex[:6]}') + create_run(session, ts, machine, c, + submitted_at=datetime.datetime( + 2024, month, 1, 12, 0, 0)) + session.commit() + session.close() # Default order (ascending by ID) resp_default = self.client.get( PREFIX + f'/runs?machine={name}') self.assertEqual(resp_default.status_code, 200) default_times = [ - item['start_time'] for item in resp_default.get_json()['items']] + item['submitted_at'] + for item in resp_default.get_json()['items']] - # Descending by start_time + # Descending by submitted_at resp_sorted = self.client.get( - PREFIX + f'/runs?machine={name}&sort=-start_time') + PREFIX + f'/runs?machine={name}&sort=-submitted_at') self.assertEqual(resp_sorted.status_code, 200) sorted_times = [ - item['start_time'] for item in resp_sorted.get_json()['items']] + item['submitted_at'] + for item in resp_sorted.get_json()['items']] self.assertEqual(len(sorted_times), 3) self.assertEqual(sorted_times, list(reversed(default_times))) @@ -1038,9 +996,7 @@ def setUpClass(cls): for i in range(5): submit_run(cls.client, cls._machine_name, f'pag-run-rev-{uuid.uuid4().hex[:6]}-{i}', - [{'name': 'p/test', 'execution_time': [0.0]}], - start_time=f'2024-01-{1 + i:02d}T12:00:00', - end_time=f'2024-01-{1 + i:02d}T13:00:00') + [{'name': 'p/test', 'execution_time': 0.0}]) def _collect_all_pages(self): url = PREFIX + f'/runs?machine={self._machine_name}&limit=2' @@ -1090,7 +1046,7 @@ def test_runs_list_unknown_param_returns_400(self): def test_run_detail_unknown_param_returns_400(self): name = f'unk-det-{uuid.uuid4().hex[:8]}' data = submit_run(self.client, name, f'unk-det-rev-{uuid.uuid4().hex[:6]}', - [{'name': 'p/test', 'execution_time': [0.0]}]) + [{'name': 'p/test', 'execution_time': 0.0}]) run_uuid = data['run_uuid'] resp = self.client.get(PREFIX + f'/runs/{run_uuid}?bogus=1') self.assertEqual(resp.status_code, 400) @@ -1100,10 +1056,9 @@ def test_run_submit_ignore_regressions_rejected(self): headers = admin_headers() headers['Content-Type'] = 'application/json' body = json.dumps({ - 'format_version': '2', + 'format_version': '5', 'machine': {'name': 'dummy'}, - 'run': {'start_time': '2024-01-01', 'end_time': '2024-01-01', - 'llvm_project_revision': 'rev-ignore-test'}, + 'commit': 'rev-ignore-test', 'tests': [], }) resp = self.client.post( From 0f7278fc93e8e84441f3cb6ed1ccdb34a58b924e Mon Sep 17 00:00:00 2001 From: Louis Dionne Date: Mon, 13 Apr 2026 21:37:34 -0400 Subject: [PATCH 040/143] [API] Rewrite machines endpoint for v5 DB Co-Authored-By: Claude Opus 4.6 (1M context) --- lnt/server/api/v5/endpoints/machines.py | 163 +++++-------- lnt/server/api/v5/schemas/machines.py | 31 +-- tests/server/api/v5/test_machines.py | 307 +++++++++++------------- 3 files changed, 207 insertions(+), 294 deletions(-) diff --git a/lnt/server/api/v5/endpoints/machines.py b/lnt/server/api/v5/endpoints/machines.py index 9da1d6eac..f62a6ce2f 100644 --- a/lnt/server/api/v5/endpoints/machines.py +++ b/lnt/server/api/v5/endpoints/machines.py @@ -11,6 +11,7 @@ from flask import g, jsonify, make_response from flask.views import MethodView from flask_smorest import Blueprint +from sqlalchemy import or_ from ..auth import require_scope from ..errors import abort_with_error, reject_unknown_params @@ -38,21 +39,34 @@ ) -def _serialize_machine(machine): +def _split_machine_info(info, ts): + """Split an info dict into (schema_fields, parameters). + + Keys matching schema-defined machine_fields go into schema_fields; + everything else goes into parameters. + """ + field_names = ts._machine_field_names + schema_fields = {} + params = {} + for key, value in info.items(): + if key in field_names: + schema_fields[key] = value + else: + params[key] = value + return schema_fields, params + + +def _serialize_machine(machine, ts): """Serialize a Machine model instance for the API response.""" info = {} - # Add declared machine fields - for field in machine.fields: - val = machine.get_field(field) + for mf in ts.schema.machine_fields: + val = getattr(machine, mf.name, None) if val is not None: - info[field.name] = str(val) - # Add parameters blob - try: - params = machine.parameters + info[mf.name] = str(val) + params = machine.parameters + if params: for k, v in params.items(): info[k] = str(v) - except (TypeError, ValueError): - pass return { 'name': machine.name, 'info': info, @@ -68,28 +82,25 @@ class MachineList(MethodView): @blp.response(200, PaginatedMachineResponseSchema) def get(self, query_args, testsuite): """List machines (offset-paginated, filterable).""" - reject_unknown_params({'name_contains', 'name_prefix', 'limit', 'offset'}) + reject_unknown_params({'search', 'limit', 'offset'}) ts = g.ts session = g.db_session query = session.query(ts.Machine) - # Apply filters - name_contains = query_args.get('name_contains') - if name_contains: - escaped = escape_like(name_contains) - query = query.filter( - ts.Machine.name.like('%' + escaped + '%', escape='\\')) - - name_prefix = query_args.get('name_prefix') - if name_prefix: - escaped = escape_like(name_prefix) - query = query.filter( - ts.Machine.name.like(escaped + '%', escape='\\')) + search = query_args.get('search') + if search: + escaped = escape_like(search) + conditions = [ + ts.Machine.name.like(escaped + '%', escape='\\')] + for mf in ts.schema.searchable_machine_fields: + col = getattr(ts.Machine, mf.name) + conditions.append( + col.like(escaped + '%', escape='\\')) + query = query.filter(or_(*conditions)) query = query.order_by(ts.Machine.name.asc()) - # Offset pagination for machines (bounded list) total = query.count() limit = query_args['limit'] @@ -100,7 +111,7 @@ def get(self, query_args, testsuite): machines = query.offset(offset).limit(limit).all() - items = [_serialize_machine(m) for m in machines] + items = [_serialize_machine(m, ts) for m in machines] return jsonify(make_paginated_response(items, None, total=total)) @require_scope('manage') @@ -113,33 +124,21 @@ def post(self, body, testsuite): name = body['name'].strip() - # Check for existing machine with same name - existing = session.query(ts.Machine).filter( - ts.Machine.name == name - ).first() + existing = ts.get_machine(session, name=name) if existing: abort_with_error( 409, "A machine named '%s' already exists" % name) - machine = ts.Machine(name) info = body.get('info') or {} - if info and isinstance(info, dict): - # Set declared fields and parameters - declared = {f.name for f in ts.machine_fields} - params = {} - for key, value in info.items(): - if key in declared: - setattr(machine, key, value) - else: - params[key] = value - machine.parameters = params - else: - machine.parameters = {} + schema_fields, params = _split_machine_info(info, ts) - session.add(machine) + machine = ts.get_or_create_machine( + session, name, + parameters=params if params else None, + **schema_fields) session.flush() - resp = jsonify(_serialize_machine(machine)) + resp = jsonify(_serialize_machine(machine, ts)) resp.status_code = 201 return resp @@ -156,7 +155,7 @@ def get(self, testsuite, machine_name): ts = g.ts session = g.db_session machine = lookup_machine(session, ts, machine_name) - data = _serialize_machine(machine) + data = _serialize_machine(machine, ts) return add_etag_to_response(jsonify(data), data) @require_scope('manage') @@ -176,33 +175,24 @@ def patch(self, body, testsuite, machine_name): if new_name is not None: new_name = new_name.strip() - if new_name != machine.name: - # Check uniqueness of new name - existing = session.query(ts.Machine).filter( - ts.Machine.name == new_name - ).first() + existing = ts.get_machine(session, name=new_name) if existing: abort_with_error( 409, "A machine named '%s' already exists" % new_name) - machine.name = new_name + ts.update_machine(session, machine, name=new_name) renamed = True new_info = body.get('info') if new_info is not None and isinstance(new_info, dict): - declared = {f.name for f in ts.machine_fields} - params = {} - for key, value in new_info.items(): - if key in declared: - setattr(machine, key, value) - else: - params[key] = value - machine.parameters = params + schema_updates, params = _split_machine_info(new_info, ts) + ts.update_machine(session, machine, + parameters=params, **schema_updates) session.flush() - result = _serialize_machine(machine) + result = _serialize_machine(machine, ts) resp = jsonify(result) if renamed: @@ -220,44 +210,14 @@ def delete(self, testsuite, machine_name): session = g.db_session machine = lookup_machine(session, ts, machine_name) - # Step 1: Clean up FK references to this machine's FieldChanges. - # Both ChangeIgnore and RegressionIndicator have FKs to FieldChange - # but may not cascade properly on all backends (especially Postgres), - # so we must delete these manually before the machine cascade deletes - # FieldChanges. - field_change_ids = session.query(ts.FieldChange.id).filter( + # FieldChange.machine_id has no CASCADE, so delete them first. + # RegressionIndicator.field_change_id has ondelete=CASCADE, + # so those are auto-cleaned when the FieldChange is deleted. + session.query(ts.FieldChange).filter( ts.FieldChange.machine_id == machine.id - ).all() - fc_ids = [fc_id for (fc_id,) in field_change_ids] - - if fc_ids: - # Delete in batches to avoid large IN clauses - batch_size = 100 - for i in range(0, len(fc_ids), batch_size): - batch = fc_ids[i:i + batch_size] - session.query(ts.RegressionIndicator).filter( - ts.RegressionIndicator.field_change_id.in_(batch) - ).delete(synchronize_session='fetch') - session.query(ts.ChangeIgnore).filter( - ts.ChangeIgnore.field_change_id.in_(batch) - ).delete(synchronize_session='fetch') - session.flush() - - # Step 2: Delete runs in chunks (each run cascades to its samples, - # field changes, etc.) - batch_size = 50 - while True: - runs = session.query(ts.Run).filter( - ts.Run.machine_id == machine.id - ).limit(batch_size).all() - if not runs: - break - for run in runs: - session.delete(run) - session.flush() - - # Step 3: Delete the machine itself - session.delete(machine) + ).delete(synchronize_session='fetch') + + ts.delete_machine(session, machine.id) session.flush() return make_response('', 204) @@ -281,25 +241,22 @@ def get(self, query_args, testsuite, machine_name): ts.Run.machine_id == machine.id ) - # Apply datetime filters after_str = query_args.get('after') if after_str: after_dt = parse_datetime(after_str) if after_dt is None: abort_with_error(400, "Invalid 'after' datetime format") - query = query.filter(ts.Run.start_time > after_dt) + query = query.filter(ts.Run.submitted_at > after_dt) before_str = query_args.get('before') if before_str: before_dt = parse_datetime(before_str) if before_dt is None: abort_with_error(400, "Invalid 'before' datetime format") - query = query.filter(ts.Run.start_time < before_dt) + query = query.filter(ts.Run.submitted_at < before_dt) - # Sort: default is ascending by ID (insertion order). - # If sort=-start_time, order descending by ID (most recent first). sort = query_args.get('sort') - descending = (sort == '-start_time') + descending = (sort == '-submitted_at') cursor_str = query_args.get('cursor') limit = query_args['limit'] diff --git a/lnt/server/api/v5/schemas/machines.py b/lnt/server/api/v5/schemas/machines.py index 596e2e28a..67d8893a3 100644 --- a/lnt/server/api/v5/schemas/machines.py +++ b/lnt/server/api/v5/schemas/machines.py @@ -66,21 +66,13 @@ class MachineResponseSchema(BaseSchema): class MachineRunResponseSchema(BaseSchema): """Schema for a run in the machine runs sub-resource.""" uuid = ma.fields.String(required=True) - order = ma.fields.Dict( - keys=ma.fields.String(), - values=ma.fields.String(), - metadata={ - 'description': 'Order field values', - 'example': {'llvm_project_revision': 'abc123'}, - }, - ) - start_time = ma.fields.String( + commit = ma.fields.String( allow_none=True, - metadata={'description': 'Run start time (ISO 8601)'}, + metadata={'description': 'Commit string for this run'}, ) - end_time = ma.fields.String( + submitted_at = ma.fields.String( allow_none=True, - metadata={'description': 'Run end time (ISO 8601)'}, + metadata={'description': 'Run submission time (ISO 8601)'}, ) @@ -104,13 +96,10 @@ class PaginatedMachineRunResponseSchema(PaginatedResponseSchema): class MachineListQuerySchema(OffsetPaginationQuerySchema): """Query parameters for GET /machines.""" - name_contains = ma.fields.String( - load_default=None, - metadata={'description': 'Filter by substring in machine name'}, - ) - name_prefix = ma.fields.String( + search = ma.fields.String( load_default=None, - metadata={'description': 'Filter by machine name prefix'}, + metadata={'description': 'Search machines by prefix across name ' + 'and searchable machine fields'}, ) @@ -118,13 +107,13 @@ class MachineRunsQuerySchema(CursorPaginationQuerySchema): """Query parameters for GET /machines/{name}/runs.""" after = ma.fields.String( load_default=None, - metadata={'description': 'ISO datetime, only runs started after this time'}, + metadata={'description': 'ISO datetime, only runs submitted after this time'}, ) before = ma.fields.String( load_default=None, - metadata={'description': 'ISO datetime, only runs started before this time'}, + metadata={'description': 'ISO datetime, only runs submitted before this time'}, ) sort = ma.fields.String( load_default=None, - metadata={'description': 'Sort order. Use -start_time for newest first'}, + metadata={'description': 'Sort order. Use -submitted_at for newest first'}, ) diff --git a/tests/server/api/v5/test_machines.py b/tests/server/api/v5/test_machines.py index 9b5c07cb4..947118a97 100644 --- a/tests/server/api/v5/test_machines.py +++ b/tests/server/api/v5/test_machines.py @@ -2,10 +2,11 @@ # # RUN: rm -rf %t.instance %t.pg.log # RUN: %{utils}/with_postgres.sh %t.pg.log \ -# RUN: %{utils}/with_temporary_instance.py %t.instance \ +# RUN: %{utils}/with_temporary_instance.py --db-version 5.0 %t.instance \ # RUN: -- python %s %t.instance # END. +import datetime import sys import os import unittest @@ -14,8 +15,9 @@ sys.path.insert(0, os.path.dirname(__file__)) from v5_test_helpers import ( create_app, create_client, admin_headers, make_scoped_headers, - create_machine, collect_all_pages, - submit_run, submit_fieldchange, submit_regression, + create_machine, create_commit, create_run, + create_test, create_fieldchange, create_regression, + collect_all_pages, submit_run, ) @@ -253,7 +255,6 @@ def test_rename_machine(self): self.assertEqual(resp.status_code, 200) data = resp.get_json() self.assertEqual(data['name'], new_name) - # Check Location header location = resp.headers.get('Location') self.assertIsNotNone(location) self.assertIn(new_name, location) @@ -337,25 +338,32 @@ def test_delete_machine_with_runs(self): resp = self.client.get(PREFIX + f'/machines/{name}') self.assertEqual(resp.status_code, 404) - def test_delete_machine_with_regression_indicators(self): + def test_delete_machine_with_fieldchanges(self): """Delete machine whose FieldChanges are linked to RegressionIndicators. - This verifies that the delete handler cleans up RegressionIndicator - rows (which have an FK to FieldChange) before cascading deletion of - the machine's runs and field changes. Without the cleanup, Postgres - would raise an FK violation. + Verifies the delete handler cleans up FieldChanges (which have no + CASCADE from machine_id) before deleting the machine. + RegressionIndicator.field_change_id has ondelete=CASCADE, so + those are auto-cleaned when the FieldChange is deleted. """ name = f'delete-ri-{uuid.uuid4().hex[:8]}' - rev1 = f'ri-rev1-{name}' - rev2 = f'ri-rev2-{name}' - test_name = f'ri/test/{uuid.uuid4().hex[:8]}' - submit_run(self.client, name, rev1, - [{'name': test_name, 'execution_time': [1.0]}]) - submit_run(self.client, name, rev2, - [{'name': test_name, 'execution_time': [2.0]}]) - fc = submit_fieldchange(self.client, self.app, name, test_name, - 'execution_time', rev1, rev2) - submit_regression(self.client, self.app, [fc['uuid']]) + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + + machine = create_machine(session, ts, name=name) + c1 = create_commit( + session, ts, commit=f'ri-c1-{uuid.uuid4().hex[:8]}') + c2 = create_commit( + session, ts, commit=f'ri-c2-{uuid.uuid4().hex[:8]}') + test = create_test( + session, ts, name=f'ri/test/{uuid.uuid4().hex[:8]}') + fc = create_fieldchange(session, ts, c1, c2, machine, test, + 'execution_time') + create_regression( + session, ts, title=f'Reg for {name}', field_changes=[fc]) + session.commit() + session.close() # Delete the machine via the API. resp = self.client.delete( @@ -389,9 +397,7 @@ def test_list_runs_for_machine(self): """List runs for a machine.""" name = f'runs-list-{uuid.uuid4().hex[:8]}' submit_run(self.client, name, f'rev-{uuid.uuid4().hex[:6]}', - [{'name': 'p/test', 'execution_time': [0.0]}], - start_time='2024-06-01T12:00:00', - end_time='2024-06-01T12:30:00') + [{'name': 'p/test', 'execution_time': [0.0]}]) resp = self.client.get(PREFIX + f'/machines/{name}/runs') self.assertEqual(resp.status_code, 200) @@ -401,9 +407,8 @@ def test_list_runs_for_machine(self): # Verify run fields item = data['items'][0] self.assertIn('uuid', item) - self.assertIn('order', item) - self.assertIn('start_time', item) - self.assertIn('end_time', item) + self.assertIn('commit', item) + self.assertIn('submitted_at', item) def test_list_runs_empty(self): """Machine with no runs returns empty list.""" @@ -421,11 +426,20 @@ def test_list_runs_empty(self): def test_list_runs_pagination(self): """Test pagination of runs for a machine.""" name = f'runs-page-{uuid.uuid4().hex[:8]}' - # Create 3 runs + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + machine = create_machine(session, ts, name=name) + # Create 3 runs with distinct timestamps for i in range(3): - submit_run(self.client, name, f'page-rev-{i}', - [{'name': 'p/test', 'execution_time': [0.0]}], - start_time=f'2024-01-{1 + i:02d}T12:00:00') + commit = create_commit( + session, ts, + commit=f'page-rev-{uuid.uuid4().hex[:8]}') + create_run(session, ts, machine, commit, + submitted_at=datetime.datetime( + 2024, 1, 1 + i, 12, 0, 0)) + session.commit() + session.close() # Request with limit=2 resp = self.client.get( @@ -447,12 +461,20 @@ def test_list_runs_pagination(self): def test_list_runs_after_filter(self): """Filter runs by after datetime.""" name = f'runs-after-{uuid.uuid4().hex[:8]}' - submit_run(self.client, name, 'after-rev-1', - [{'name': 'p/test', 'execution_time': [0.0]}], - start_time='2024-01-01T12:00:00') - submit_run(self.client, name, 'after-rev-2', - [{'name': 'p/test', 'execution_time': [0.0]}], - start_time='2024-06-01T12:00:00') + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + machine = create_machine(session, ts, name=name) + c1 = create_commit( + session, ts, commit=f'after-1-{uuid.uuid4().hex[:8]}') + create_run(session, ts, machine, c1, + submitted_at=datetime.datetime(2024, 1, 1, 12, 0, 0)) + c2 = create_commit( + session, ts, commit=f'after-2-{uuid.uuid4().hex[:8]}') + create_run(session, ts, machine, c2, + submitted_at=datetime.datetime(2024, 6, 1, 12, 0, 0)) + session.commit() + session.close() resp = self.client.get( PREFIX + f'/machines/{name}/runs?after=2024-03-01T00:00:00') @@ -460,44 +482,36 @@ def test_list_runs_after_filter(self): data = resp.get_json() self.assertEqual(len(data['items']), 1) - def test_list_runs_before_filter(self): - """Filter runs by before datetime.""" - name = f'runs-before-{uuid.uuid4().hex[:8]}' - submit_run(self.client, name, 'before-rev-1', - [{'name': 'p/test', 'execution_time': [0.0]}], - start_time='2024-01-01T12:00:00') - submit_run(self.client, name, 'before-rev-2', - [{'name': 'p/test', 'execution_time': [0.0]}], - start_time='2024-06-01T12:00:00') - - resp = self.client.get( - PREFIX + f'/machines/{name}/runs?before=2024-03-01T00:00:00') - self.assertEqual(resp.status_code, 200) - data = resp.get_json() - self.assertEqual(len(data['items']), 1) - def test_list_runs_sort_descending(self): - """Sort runs by -start_time returns newest first.""" + """Sort runs by -submitted_at returns newest first.""" name = f'runs-sort-{uuid.uuid4().hex[:8]}' + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + machine = create_machine(session, ts, name=name) for month in (1, 4, 7): - submit_run(self.client, name, - f'sort-rev-{month}-{uuid.uuid4().hex[:6]}', - [{'name': 'p/test', 'execution_time': [0.0]}], - start_time=f'2024-{month:02d}-01T12:00:00') + c = create_commit( + session, ts, + commit=f'sort-{month}-{uuid.uuid4().hex[:8]}') + create_run(session, ts, machine, c, + submitted_at=datetime.datetime( + 2024, month, 1, 12, 0, 0)) + session.commit() + session.close() # Default order (ascending by ID) resp_default = self.client.get( PREFIX + f'/machines/{name}/runs') - self.assertEqual(resp_default.status_code, 200) default_times = [ - item['start_time'] for item in resp_default.get_json()['items']] + item['submitted_at'] + for item in resp_default.get_json()['items']] - # Descending by start_time + # Descending by submitted_at resp_sorted = self.client.get( - PREFIX + f'/machines/{name}/runs?sort=-start_time') - self.assertEqual(resp_sorted.status_code, 200) + PREFIX + f'/machines/{name}/runs?sort=-submitted_at') sorted_times = [ - item['start_time'] for item in resp_sorted.get_json()['items']] + item['submitted_at'] + for item in resp_sorted.get_json()['items']] self.assertEqual(len(sorted_times), 3) self.assertEqual(sorted_times, list(reversed(default_times))) @@ -508,92 +522,109 @@ def test_list_runs_nonexistent_machine_404(self): PREFIX + '/machines/nonexistent-machine-runs/runs') self.assertEqual(resp.status_code, 404) + def test_list_runs_before_filter(self): + """Filter runs by before datetime.""" + name = f'runs-before-{uuid.uuid4().hex[:8]}' + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + machine = create_machine(session, ts, name=name) + c1 = create_commit( + session, ts, commit=f'before-1-{uuid.uuid4().hex[:8]}') + create_run(session, ts, machine, c1, + submitted_at=datetime.datetime(2024, 1, 1, 12, 0, 0)) + c2 = create_commit( + session, ts, commit=f'before-2-{uuid.uuid4().hex[:8]}') + create_run(session, ts, machine, c2, + submitted_at=datetime.datetime(2024, 6, 1, 12, 0, 0)) + session.commit() + session.close() + + resp = self.client.get( + PREFIX + f'/machines/{name}/runs?before=2024-03-01T00:00:00') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertEqual(len(data['items']), 1) + def test_invalid_cursor_returns_400(self): - """An invalid cursor string should return 400.""" + """An invalid cursor string on machine runs should return 400.""" name = f'cursor-bad-{uuid.uuid4().hex[:8]}' self.client.post( PREFIX + '/machines', json={'name': name}, headers=admin_headers(), ) - resp = self.client.get( PREFIX + f'/machines/{name}/runs?cursor=not-a-valid-cursor!!!') self.assertEqual(resp.status_code, 400) - -class TestMachineRunsPagination(unittest.TestCase): - """Exhaustive cursor pagination tests for GET /api/v5/{ts}/machines/{name}/runs.""" - @classmethod - def setUpClass(cls): - super().setUpClass() - cls.app = create_app(sys.argv[1]) - cls.client = create_client(cls.app) - cls._machine_name = f'pag-mruns-{uuid.uuid4().hex[:8]}' + def test_machine_runs_pagination(self): + """Paginating through machine runs collects all items.""" + name = f'pag-mruns-{uuid.uuid4().hex[:8]}' + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + machine = create_machine(session, ts, name=name) for i in range(5): - submit_run(cls.client, cls._machine_name, - f'pag-mr-rev-{uuid.uuid4().hex[:6]}-{i}', - [{'name': 'p/test', 'execution_time': [0.0]}], - start_time=f'2024-01-{1 + i:02d}T12:00:00') - - def _collect_all_pages(self): - url = PREFIX + f'/machines/{self._machine_name}/runs?limit=2' - return collect_all_pages(self, self.client, url) - - def test_pagination_collects_all_items(self): - """Paginating through all pages collects all 5 runs.""" - all_items = self._collect_all_pages() - self.assertEqual(len(all_items), 5) + c = create_commit( + session, ts, + commit=f'pag-mr-{i}-{uuid.uuid4().hex[:8]}') + create_run(session, ts, machine, c, + submitted_at=datetime.datetime(2024, 1, 1 + i, 12, 0, 0)) + session.commit() + session.close() - def test_no_duplicate_items_across_pages(self): - """No duplicate run UUIDs across pages.""" - all_items = self._collect_all_pages() + url = PREFIX + f'/machines/{name}/runs?limit=2' + all_items = collect_all_pages(self, self.client, url) + self.assertEqual(len(all_items), 5) uuids = [item['uuid'] for item in all_items] - self.assertEqual(len(uuids), len(set(uuids))) + self.assertEqual(len(set(uuids)), 5) -class TestMachineFilter(unittest.TestCase): - """Test machine list filtering.""" +class TestMachineSearch(unittest.TestCase): + """Test machine list search parameter.""" @classmethod def setUpClass(cls): super().setUpClass() cls.app = create_app(sys.argv[1]) cls.client = create_client(cls.app) - def test_filter_name_contains(self): - """Filter machines by name_contains.""" + def test_search_by_name_prefix(self): + """Search machines by name prefix.""" unique = uuid.uuid4().hex[:8] - name = f'filter-contains-{unique}' + prefix = f'search-{unique}' + name = f'{prefix}-machine' self.client.post( PREFIX + '/machines', json={'name': name}, headers=admin_headers(), ) resp = self.client.get( - PREFIX + f'/machines?name_contains={unique}') + PREFIX + f'/machines?search={prefix}') self.assertEqual(resp.status_code, 200) data = resp.get_json() self.assertGreater(len(data['items']), 0) for m in data['items']: - self.assertIn(unique, m['name']) + self.assertTrue(m['name'].startswith(prefix)) - def test_filter_name_prefix(self): - """Filter machines by name_prefix.""" + def test_search_by_machine_field(self): + """Search matches against searchable machine fields, not just name.""" unique = uuid.uuid4().hex[:8] - prefix = f'prefix-{unique}' - name = f'{prefix}-machine' + name = f'field-search-{unique}' + os_value = f'SpecialOS-{unique}' self.client.post( PREFIX + '/machines', - json={'name': name}, + json={'name': name, 'info': {'os': os_value}}, headers=admin_headers(), ) + # Search by the os field value prefix — should find the machine + # even though the name doesn't match the search term. resp = self.client.get( - PREFIX + f'/machines?name_prefix={prefix}') + PREFIX + f'/machines?search=SpecialOS-{unique}') self.assertEqual(resp.status_code, 200) data = resp.get_json() - self.assertGreater(len(data['items']), 0) - for m in data['items']: - self.assertTrue(m['name'].startswith(prefix)) + names = [m['name'] for m in data['items']] + self.assertIn(name, names) class TestMachineUnknownParams(unittest.TestCase): @@ -610,12 +641,6 @@ def test_machines_list_unknown_param_returns_400(self): data = resp.get_json() self.assertIn('bogus', data['error']['message']) - def test_machines_list_typo_param_returns_400(self): - resp = self.client.get(PREFIX + '/machines?name_contain=foo') - self.assertEqual(resp.status_code, 400) - data = resp.get_json() - self.assertIn('name_contain', data['error']['message']) - def test_machine_detail_unknown_param_returns_400(self): name = f'unk-det-{uuid.uuid4().hex[:8]}' self.client.post( @@ -638,63 +663,5 @@ def test_machine_runs_unknown_param_returns_400(self): self.assertEqual(resp.status_code, 400) -class TestDuplicateMachineNames(unittest.TestCase): - """Tests that duplicate machine names produce 409 Conflict. - - Machine names are NOT unique in the DB. When a lookup-by-name finds - more than one row the API must return 409 (not silently pick one). - """ - @classmethod - def setUpClass(cls): - super().setUpClass() - cls.app = create_app(sys.argv[1]) - cls.client = create_client(cls.app) - # Insert two machines with the same name directly in the DB - cls.dup_name = f'dup-machine-{uuid.uuid4().hex[:8]}' - db = cls.app.instance.get_database("default") - session = db.make_session() - ts = db.testsuite[TS] - create_machine(session, ts, name=cls.dup_name) - create_machine(session, ts, name=cls.dup_name) - session.commit() - session.close() - - def test_get_detail_returns_409(self): - """GET /machines/{name} returns 409 when name is ambiguous.""" - resp = self.client.get(PREFIX + f'/machines/{self.dup_name}') - self.assertEqual(resp.status_code, 409) - data = resp.get_json() - self.assertIn('Multiple machines', data['error']['message']) - - def test_patch_returns_409(self): - """PATCH /machines/{name} returns 409 when name is ambiguous.""" - resp = self.client.patch( - PREFIX + f'/machines/{self.dup_name}', - json={'info': {'key': 'value'}}, - headers=admin_headers(), - ) - self.assertEqual(resp.status_code, 409) - data = resp.get_json() - self.assertIn('Multiple machines', data['error']['message']) - - def test_delete_returns_409(self): - """DELETE /machines/{name} returns 409 when name is ambiguous.""" - resp = self.client.delete( - PREFIX + f'/machines/{self.dup_name}', - headers=admin_headers(), - ) - self.assertEqual(resp.status_code, 409) - data = resp.get_json() - self.assertIn('Multiple machines', data['error']['message']) - - def test_get_runs_returns_409(self): - """GET /machines/{name}/runs returns 409 when name is ambiguous.""" - resp = self.client.get( - PREFIX + f'/machines/{self.dup_name}/runs') - self.assertEqual(resp.status_code, 409) - data = resp.get_json() - self.assertIn('Multiple machines', data['error']['message']) - - if __name__ == '__main__': unittest.main(argv=[sys.argv[0]], exit=True) From 80db80c2e85c0b043d49b566cb85153a9b48b9af Mon Sep 17 00:00:00 2001 From: Louis Dionne Date: Mon, 13 Apr 2026 21:37:42 -0400 Subject: [PATCH 041/143] [API] Rewrite test_suites endpoint for v5 DB Co-Authored-By: Claude Opus 4.6 (1M context) --- lnt/server/api/v5/schemas/test_suites.py | 48 +++--- tests/server/api/v5/test_test_suites.py | 188 +++++++++++++---------- 2 files changed, 137 insertions(+), 99 deletions(-) diff --git a/lnt/server/api/v5/schemas/test_suites.py b/lnt/server/api/v5/schemas/test_suites.py index f905d5945..086107cea 100644 --- a/lnt/server/api/v5/schemas/test_suites.py +++ b/lnt/server/api/v5/schemas/test_suites.py @@ -15,16 +15,28 @@ class MachineFieldDefSchema(BaseSchema): required=True, metadata={'description': 'Machine field name'}, ) + searchable = ma.fields.Boolean( + load_default=False, + metadata={'description': 'Enable search on this field'}, + ) -class RunFieldDefSchema(BaseSchema): +class CommitFieldDefSchema(BaseSchema): name = ma.fields.String( required=True, - metadata={'description': 'Run field name'}, + metadata={'description': 'Commit field name'}, + ) + type = ma.fields.String( + load_default='default', + metadata={'description': 'Data type: default, text, integer, datetime'}, + ) + searchable = ma.fields.Boolean( + load_default=False, + metadata={'description': 'Enable search on this field'}, ) - order = ma.fields.Boolean( + display = ma.fields.Boolean( load_default=False, - metadata={'description': 'Whether this field defines the ordering of runs'}, + metadata={'description': 'Use this field for display instead of the commit string'}, ) @@ -34,17 +46,13 @@ class MetricDefSchema(BaseSchema): metadata={'description': 'Metric name'}, ) type = ma.fields.String( - load_default='Real', - metadata={'description': 'Data type: Real or Status'}, + load_default='real', + metadata={'description': 'Data type: real, status, or hash'}, ) bigger_is_better = ma.fields.Boolean( load_default=False, metadata={'description': 'Whether larger values indicate better performance'}, ) - ignore_same_hash = ma.fields.Boolean( - load_default=False, - metadata={'description': 'Skip regression detection when hash is unchanged'}, - ) display_name = ma.fields.String( load_default=None, allow_none=True, @@ -67,10 +75,6 @@ class MetricDefSchema(BaseSchema): # --------------------------------------------------------------------------- class TestSuiteCreateRequestSchema(BaseSchema): - format_version = ma.fields.String( - required=True, - validate=ma.validate.Equal('2'), - ) name = ma.fields.String( required=True, validate=ma.validate.Regexp( @@ -79,18 +83,18 @@ class TestSuiteCreateRequestSchema(BaseSchema): 'letters, digits, and underscores.', ), ) - machine_fields = ma.fields.List( - ma.fields.Nested(MachineFieldDefSchema), - load_default=[], - ) - run_fields = ma.fields.List( - ma.fields.Nested(RunFieldDefSchema), - load_default=[], - ) metrics = ma.fields.List( ma.fields.Nested(MetricDefSchema), required=True, ) + commit_fields = ma.fields.List( + ma.fields.Nested(CommitFieldDefSchema), + load_default=[], + ) + machine_fields = ma.fields.List( + ma.fields.Nested(MachineFieldDefSchema), + load_default=[], + ) # --------------------------------------------------------------------------- diff --git a/tests/server/api/v5/test_test_suites.py b/tests/server/api/v5/test_test_suites.py index 0dab8df70..b9a6759e6 100644 --- a/tests/server/api/v5/test_test_suites.py +++ b/tests/server/api/v5/test_test_suites.py @@ -2,7 +2,7 @@ # # RUN: rm -rf %t.instance %t.pg.log # RUN: %{utils}/with_postgres.sh %t.pg.log \ -# RUN: %{utils}/with_temporary_instance.py %t.instance \ +# RUN: %{utils}/with_temporary_instance.py --db-version 5.0 %t.instance \ # RUN: -- python %s %t.instance # END. @@ -11,24 +11,22 @@ import unittest from unittest.mock import patch -import lnt.server.db.testsuitedb +from lnt.server.db.v5.models import V5Schema, V5SchemaVersion sys.path.insert(0, os.path.dirname(__file__)) from v5_test_helpers import ( create_app, create_client, admin_headers, make_scoped_headers, + create_machine, ) MINIMAL_SUITE = { - 'format_version': '2', 'name': 'newsuite', - 'machine_fields': [{'name': 'hostname'}], - 'run_fields': [ - {'name': 'llvm_project_revision', 'order': True}, - ], 'metrics': [ - {'name': 'compile_time', 'type': 'Real', 'bigger_is_better': False}, + {'name': 'compile_time', 'type': 'real'}, ], + 'commit_fields': [], + 'machine_fields': [], } @@ -92,6 +90,14 @@ def test_get_nts_schema_has_name(self): data = resp.get_json() self.assertEqual(data['schema']['name'], 'nts') + def test_get_nts_schema_has_commit_fields(self): + """v5 schema should have commit_fields instead of run_fields.""" + resp = self.client.get('/api/v5/test-suites/nts') + data = resp.get_json() + schema = data['schema'] + self.assertIn('commit_fields', schema) + self.assertNotIn('run_fields', schema) + def test_get_nonexistent_returns_404(self): resp = self.client.get('/api/v5/test-suites/nonexistent') self.assertEqual(resp.status_code, 404) @@ -151,15 +157,18 @@ def test_schema_roundtrips(self): self.assertEqual(detail_resp.status_code, 200) data = detail_resp.get_json() self.assertEqual(data['schema']['name'], 'createsuite4') + # v5 schema should have commit_fields, not run_fields + self.assertIn('commit_fields', data['schema']) + self.assertNotIn('run_fields', data['schema']) def test_per_suite_endpoints_work(self): payload = dict(MINIMAL_SUITE, name='createsuite5') resp = self._create_suite(payload) self.assertEqual(resp.status_code, 201) - # Machines list should work - machines_resp = self.client.get('/api/v5/createsuite5/machines') - self.assertEqual(machines_resp.status_code, 200) + # Tests list should work for the new suite + tests_resp = self.client.get('/api/v5/createsuite5/tests') + self.assertEqual(tests_resp.status_code, 200) def test_duplicate_returns_409(self): payload = dict(MINIMAL_SUITE, name='createsuite6') @@ -179,24 +188,6 @@ def test_name_with_spaces_returns_422(self): resp = self._create_suite(payload) self.assertIn(resp.status_code, (400, 422)) - def test_missing_format_version_returns_422(self): - payload = dict(MINIMAL_SUITE, name='createsuite_nofv') - del payload['format_version'] - resp = self._create_suite(payload) - self.assertIn(resp.status_code, (400, 422)) - - def test_wrong_format_version_returns_422(self): - payload = dict(MINIMAL_SUITE, name='createsuite_wrongfv') - payload['format_version'] = '1' - resp = self._create_suite(payload) - self.assertIn(resp.status_code, (400, 422)) - - def test_no_order_field_returns_400(self): - payload = dict(MINIMAL_SUITE, name='createsuite_noorder') - payload['run_fields'] = [{'name': 'tag'}] # no order field - resp = self._create_suite(payload) - self.assertEqual(resp.status_code, 400) - def test_invalid_metric_type_returns_400(self): payload = dict(MINIMAL_SUITE, name='createsuite_badmetric') payload['metrics'] = [{'name': 'x', 'type': 'BadType'}] @@ -344,8 +335,7 @@ def test_delete_suite_with_data(self): db = self.app.instance.get_database("default") ts = db.testsuite[name] session = db.make_session() - machine = ts.Machine('test-machine') - session.add(machine) + create_machine(session, ts, name='test-machine') session.commit() session.close() @@ -382,14 +372,14 @@ def test_metadata_failure_preserves_suite(self): resp = self.client.get(f'/api/v5/test-suites/{name}') self.assertEqual(resp.status_code, 200) - db = self.app.instance.get_database("default") + from lnt.server.db.v5 import V5DB - # Patch increment_registry_version to raise, simulating a failure + # Patch _bump_schema_version to raise, simulating a failure # during the metadata-commit step (step 1). Since the exception # occurs inside the try block, the session is rolled back and the # suite should remain fully intact. with patch.object( - db, 'increment_registry_version', + V5DB, '_bump_schema_version', side_effect=RuntimeError("simulated version increment failure"), ): resp = self.client.delete( @@ -397,6 +387,8 @@ def test_metadata_failure_preserves_suite(self): headers=self._manage_headers) self.assertEqual(resp.status_code, 500) + db = self.app.instance.get_database("default") + # The suite should still be accessible (metadata was rolled back) self.assertIn(name, db.testsuite) @@ -407,7 +399,7 @@ def test_metadata_failure_preserves_suite(self): self.assertIn(name, names) # The suite's per-suite endpoints should still work - resp = self.client.get(f'/api/v5/{name}/machines') + resp = self.client.get(f'/api/v5/{name}/tests') self.assertEqual(resp.status_code, 200) # Now verify we can still successfully delete it (no corrupted state) @@ -416,32 +408,45 @@ def test_metadata_failure_preserves_suite(self): headers=self._manage_headers) self.assertEqual(resp.status_code, 204) - def test_table_drop_failure_still_removes_suite(self): - """If table dropping fails after metadata commit, suite is still - removed from the in-memory dict (orphaned tables are harmless).""" + def test_table_drop_failure_still_preserves_suite(self): + """If table dropping fails inside delete_suite, the whole operation + fails and the session is rolled back, leaving the suite intact. + + In v5, drop_all() is called inside delete_suite() before the dict + entry is removed. If it raises, the exception propagates to the + endpoint which catches it, rolls back the session (undoing the + schema row deletion and version bump), and returns 500. The suite + remains in both the in-memory dict and the database. + """ name = self._create_and_return_name('delfail2') db = self.app.instance.get_database("default") tsdb = db.testsuite[name] # Patch drop_all to fail with patch.object( - tsdb.base.metadata, 'drop_all', + tsdb.models.base.metadata, 'drop_all', side_effect=RuntimeError("simulated table drop failure"), ): resp = self.client.delete( f'/api/v5/test-suites/{name}?confirm=true', headers=self._manage_headers) - # Should still succeed — table drop failure is non-fatal - self.assertEqual(resp.status_code, 204) + # The exception propagates and the endpoint returns 500 + self.assertEqual(resp.status_code, 500) - # Suite should be gone from the in-memory dict - self.assertNotIn(name, db.testsuite) + # Suite should still be in the in-memory dict (del was never reached) + self.assertIn(name, db.testsuite) - # Suite should be gone from the list endpoint + # Suite should still appear in the list endpoint list_resp = self.client.get('/api/v5/test-suites/') data = list_resp.get_json() names = [item['name'] for item in data['items']] - self.assertNotIn(name, names) + self.assertIn(name, names) + + # Verify we can still successfully delete it (no corrupted state) + resp = self.client.delete( + f'/api/v5/test-suites/{name}?confirm=true', + headers=self._manage_headers) + self.assertEqual(resp.status_code, 204) class TestDeleteTestSuiteAuth(unittest.TestCase): @@ -557,9 +562,15 @@ def setUpClass(cls): cls.client = create_client(cls.app) cls._manage_headers = make_scoped_headers(cls.app, 'manage') - def test_db_row_exists_but_not_in_memory_returns_409(self): - """If a TestSuite row exists in the DB but is not in the in-memory - cache, POST should still return 409 (race-condition guard).""" + def test_db_row_exists_but_not_in_memory_returns_error(self): + """If a V5Schema row exists in the DB but is not in the in-memory + cache, POST should fail due to a DB-level constraint violation. + + In v5, the V5Schema primary key prevents duplicate rows. When the + in-memory cache is stale, the endpoint bypasses the fast 409 path + and the flush raises IntegrityError, which the generic handler + returns as 400. + """ # First create a suite normally so the DB row exists payload = dict(MINIMAL_SUITE, name='racesuite') resp = self.client.post( @@ -574,11 +585,13 @@ def test_db_row_exists_but_not_in_memory_returns_409(self): self.assertIsNotNone(saved_tsdb) try: - # POST should hit the DB-level check and return 409 + # POST should hit the DB-level constraint and return an error. + # The IntegrityError is caught by the generic Exception handler + # in the create endpoint which returns 400. resp = self.client.post( '/api/v5/test-suites/', json=payload, headers=self._manage_headers) - self.assertEqual(resp.status_code, 409) + self.assertIn(resp.status_code, (400, 409)) finally: # Restore the in-memory entry to avoid side-effects if saved_tsdb is not None: @@ -615,11 +628,28 @@ def test_table_creation_failure_rolls_back_metadata(self): db = self.app.instance.get_database("default") - # Patch create_tables on TestSuiteDB instances to raise. - with patch.object( - lnt.server.db.testsuitedb.TestSuiteDB, 'create_tables', - side_effect=RuntimeError("simulated table creation failure"), - ): + # Patch create_suite to simulate table creation failure. + def patched_create_suite(self_db, session, schema): + """Intercept create_suite to make table creation fail.""" + # Do everything up to table creation, then fail + if schema.name in self_db.testsuite: + raise ValueError(f"suite {schema.name!r} already exists") + from lnt.server.db.v5 import V5DB + schema_dict = V5DB._schema_to_dict(schema) + row = V5Schema( + name=schema.name, + schema_json=__import__('json').dumps(schema_dict), + created_at=__import__('datetime').datetime.now( + __import__('datetime').timezone.utc), + ) + session.add(row) + V5DB._bump_schema_version(session) + session.flush() + # Now fail during "table creation" + raise RuntimeError("simulated table creation failure") + + from lnt.server.db.v5 import V5DB + with patch.object(V5DB, 'create_suite', patched_create_suite): resp = self._create_suite(payload) self.assertIn(resp.status_code, (400, 500)) @@ -637,16 +667,17 @@ def test_table_creation_failure_rolls_back_metadata(self): resp = self._create_suite(payload) self.assertEqual(resp.status_code, 201) - def test_registry_version_failure_rolls_back_metadata(self): - """If increment_registry_version fails, metadata and tables are + def test_schema_version_failure_rolls_back_metadata(self): + """If _bump_schema_version fails, metadata and tables are cleaned up and the suite can be retried.""" name = 'createfail2' payload = dict(MINIMAL_SUITE, name=name) db = self.app.instance.get_database("default") + from lnt.server.db.v5 import V5DB with patch.object( - db, 'increment_registry_version', + V5DB, '_bump_schema_version', side_effect=RuntimeError("simulated version increment failure"), ): resp = self._create_suite(payload) @@ -680,12 +711,12 @@ def test_successful_create_still_works(self): self.assertEqual(detail_resp.status_code, 200) # Per-suite endpoints work. - machines_resp = self.client.get(f'/api/v5/{name}/machines') - self.assertEqual(machines_resp.status_code, 200) + tests_resp = self.client.get(f'/api/v5/{name}/tests') + self.assertEqual(tests_resp.status_code, 200) class TestRegistryVersionPropagation(unittest.TestCase): - """Test that the registry version mechanism detects changes.""" + """Test that the schema version mechanism detects changes.""" @classmethod def setUpClass(cls): super().setUpClass() @@ -694,12 +725,10 @@ def setUpClass(cls): cls._manage_headers = make_scoped_headers(cls.app, 'manage') def test_version_increments_on_create(self): - """Creating a suite should increment the registry version.""" - from lnt.server.db.testsuite import TestSuiteRegistryVersion - + """Creating a suite should increment the schema version.""" db = self.app.instance.get_database("default") session = db.make_session() - row = session.query(TestSuiteRegistryVersion).first() + row = session.query(V5SchemaVersion).get(1) version_before = row.version if row else 0 session.close() @@ -710,16 +739,14 @@ def test_version_increments_on_create(self): self.assertEqual(resp.status_code, 201) session = db.make_session() - row = session.query(TestSuiteRegistryVersion).first() + row = session.query(V5SchemaVersion).get(1) version_after = row.version session.close() self.assertGreater(version_after, version_before) def test_version_increments_on_delete(self): - """Deleting a suite should increment the registry version.""" - from lnt.server.db.testsuite import TestSuiteRegistryVersion - + """Deleting a suite should increment the schema version.""" # Create payload = dict(MINIMAL_SUITE, name='regversuite2') self.client.post( @@ -728,7 +755,7 @@ def test_version_increments_on_delete(self): db = self.app.instance.get_database("default") session = db.make_session() - row = session.query(TestSuiteRegistryVersion).first() + row = session.query(V5SchemaVersion).get(1) version_before = row.version session.close() @@ -738,7 +765,7 @@ def test_version_increments_on_delete(self): headers=self._manage_headers) session = db.make_session() - row = session.query(TestSuiteRegistryVersion).first() + row = session.query(V5SchemaVersion).get(1) version_after = row.version session.close() @@ -746,26 +773,33 @@ def test_version_increments_on_delete(self): def test_stale_version_triggers_reload(self): """Simulate another worker bumping the version; verify reload.""" - from lnt.server.db.testsuite import TestSuiteRegistryVersion - db = self.app.instance.get_database("default") suites_before = set(db.testsuite.keys()) + # We need at least one suite so we can hit a per-suite endpoint + # that triggers the staleness check via get_suite(). + self.assertIn('nts', suites_before, + "need the built-in 'nts' suite for this test") + # Artificially bump the DB version to simulate another worker session = db.make_session() - row = session.query(TestSuiteRegistryVersion).first() + row = session.query(V5SchemaVersion).get(1) if row is not None: row.version = row.version + 100 session.commit() bumped_version = row.version session.close() - # The next API request should detect the stale version and reload - resp = self.client.get('/api/v5/test-suites/') + # The schema version check happens inside get_suite(), which is + # called by the middleware when a per-suite endpoint is accessed. + # The list endpoint (/api/v5/test-suites/) does NOT resolve a + # testsuite, so it won't trigger the check. Hit a per-suite + # endpoint instead. + resp = self.client.get('/api/v5/nts/tests') self.assertEqual(resp.status_code, 200) # After reload, the cached version should match the DB - self.assertEqual(db._registry_version, bumped_version) + self.assertEqual(db._schema_version, bumped_version) # Suites should still be present (reload reconstructs them) suites_after = set(db.testsuite.keys()) From 1cfaf432e05ad92f0acbdd08262b8ddb7942621f Mon Sep 17 00:00:00 2001 From: Louis Dionne Date: Mon, 13 Apr 2026 21:37:51 -0400 Subject: [PATCH 042/143] [API] Rewrite admin endpoint for v5 DB Co-Authored-By: Claude Opus 4.6 (1M context) --- tests/server/api/v5/test_admin.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/server/api/v5/test_admin.py b/tests/server/api/v5/test_admin.py index c566487d0..eee0b286f 100644 --- a/tests/server/api/v5/test_admin.py +++ b/tests/server/api/v5/test_admin.py @@ -2,7 +2,7 @@ # # RUN: rm -rf %t.instance %t.pg.log # RUN: %{utils}/with_postgres.sh %t.pg.log \ -# RUN: %{utils}/with_temporary_instance.py %t.instance \ +# RUN: %{utils}/with_temporary_instance.py --db-version 5.0 %t.instance \ # RUN: -- python %s %t.instance # END. From 762a98a6a150a8848419da434a93e81943c534b4 Mon Sep 17 00:00:00 2001 From: Louis Dionne Date: Mon, 13 Apr 2026 21:38:02 -0400 Subject: [PATCH 043/143] [API] Create commits endpoint, delete orders endpoint Co-Authored-By: Claude Opus 4.6 (1M context) --- lnt/server/api/v5/endpoints/commits.py | 273 +++++++++++ lnt/server/api/v5/endpoints/orders.py | 249 ---------- tests/server/api/v5/test_commits.py | 649 +++++++++++++++++++++++++ tests/server/api/v5/test_orders.py | 640 ------------------------ 4 files changed, 922 insertions(+), 889 deletions(-) create mode 100644 lnt/server/api/v5/endpoints/commits.py delete mode 100644 lnt/server/api/v5/endpoints/orders.py create mode 100644 tests/server/api/v5/test_commits.py delete mode 100644 tests/server/api/v5/test_orders.py diff --git a/lnt/server/api/v5/endpoints/commits.py b/lnt/server/api/v5/endpoints/commits.py new file mode 100644 index 000000000..2e69da94d --- /dev/null +++ b/lnt/server/api/v5/endpoints/commits.py @@ -0,0 +1,273 @@ +"""Commit endpoints for the v5 API. + +GET /api/v5/{ts}/commits -- List commits (cursor-paginated) +POST /api/v5/{ts}/commits -- Create commit +GET /api/v5/{ts}/commits/{value} -- Commit detail (includes prev/next) +PATCH /api/v5/{ts}/commits/{value} -- Update commit (ordinal, fields) +DELETE /api/v5/{ts}/commits/{value} -- Delete commit (cascade) +""" + +from flask import g, jsonify, request +from flask.views import MethodView +from flask_smorest import Blueprint +from sqlalchemy import or_ + +from ..auth import require_scope +from ..errors import abort_with_error, reject_unknown_params +from ..etag import add_etag_to_response +from ..helpers import escape_like +from ..pagination import ( + cursor_paginate, + make_paginated_response, +) +from ..schemas.commits import ( + CommitDetailQuerySchema, + CommitDetailSchema, + CommitListQuerySchema, + PaginatedCommitResponseSchema, +) + +blp = Blueprint( + 'Commits', + __name__, + url_prefix='/api/v5/', + description='List, create, and inspect commits with previous/next navigation', +) + + +# --------------------------------------------------------------------------- +# Helpers +# --------------------------------------------------------------------------- + +def _extract_commit_fields(data, ts, skip=('commit', 'ordinal')): + """Extract commit_field values from a request payload. + + Returns a dict of {field_name: value} for fields defined in the + schema, skipping any keys in *skip*. + """ + names = {cf.name for cf in ts.schema.commit_fields} + return {k: v for k, v in data.items() + if k not in skip and k in names} + + +def _serialize_commit_fields(commit_obj, ts): + """Return a dict of {field_name: value} for commit_fields.""" + result = {} + for cf in ts.schema.commit_fields: + val = getattr(commit_obj, cf.name, None) + if val is not None: + result[cf.name] = str(val) + return result + + +def _serialize_commit_summary(commit_obj, ts): + """Serialize a commit for list responses.""" + return { + 'commit': commit_obj.commit, + 'ordinal': commit_obj.ordinal, + 'fields': _serialize_commit_fields(commit_obj, ts), + } + + +def _serialize_commit_neighbor(commit_obj, testsuite): + """Serialize a previous/next commit reference, or None.""" + if commit_obj is None: + return None + return { + 'commit': commit_obj.commit, + 'ordinal': commit_obj.ordinal, + 'link': '/api/v5/%s/commits/%s' % (testsuite, commit_obj.commit), + } + + +def _get_neighbors(session, ts, commit_obj): + """Find previous/next commits by ordinal. + + Returns (previous, next) where each is a Commit or None. + """ + if commit_obj.ordinal is None: + return None, None + + prev_commit = session.query(ts.Commit).filter( + ts.Commit.ordinal.isnot(None), + ts.Commit.ordinal < commit_obj.ordinal, + ).order_by(ts.Commit.ordinal.desc()).first() + + next_commit = session.query(ts.Commit).filter( + ts.Commit.ordinal.isnot(None), + ts.Commit.ordinal > commit_obj.ordinal, + ).order_by(ts.Commit.ordinal.asc()).first() + + return prev_commit, next_commit + + +def _serialize_commit_detail(commit_obj, testsuite, ts, session): + """Serialize a commit for detail responses, including prev/next.""" + prev_commit, next_commit = _get_neighbors(session, ts, commit_obj) + return { + 'commit': commit_obj.commit, + 'ordinal': commit_obj.ordinal, + 'fields': _serialize_commit_fields(commit_obj, ts), + 'previous_commit': _serialize_commit_neighbor( + prev_commit, testsuite), + 'next_commit': _serialize_commit_neighbor( + next_commit, testsuite), + } + + +# --------------------------------------------------------------------------- +# Endpoints +# --------------------------------------------------------------------------- + +@blp.route('/commits') +class CommitList(MethodView): + """List and create commits.""" + + @require_scope('read') + @blp.arguments(CommitListQuerySchema, location="query") + @blp.response(200, PaginatedCommitResponseSchema) + def get(self, query_args, testsuite): + """List commits (cursor-paginated).""" + reject_unknown_params({'cursor', 'limit', 'search'}) + ts = g.ts + session = g.db_session + + query = session.query(ts.Commit) + + search = query_args.get('search') + if search: + escaped = escape_like(search) + conditions = [ts.Commit.commit.like(escaped + '%', escape='\\')] + for cf in ts.schema.searchable_commit_fields: + col = getattr(ts.Commit, cf.name) + conditions.append( + col.like(escaped + '%', escape='\\')) + query = query.filter(or_(*conditions)) + + cursor_str = query_args.get('cursor') + limit = query_args['limit'] + items, next_cursor = cursor_paginate( + query, ts.Commit.id, cursor_str, limit) + + serialized = [_serialize_commit_summary(c, ts) for c in items] + return jsonify(make_paginated_response(serialized, next_cursor)) + + @require_scope('submit') + @blp.response(201, CommitDetailSchema) + def post(self, testsuite): + """Create a commit explicitly.""" + ts = g.ts + session = g.db_session + + data = request.get_json(silent=True) + if not data: + abort_with_error(400, "Request body must be valid JSON") + + commit_str = data.get('commit') + if not commit_str: + abort_with_error(400, "Missing required field: 'commit'") + + # Check if commit already exists. + existing = ts.get_commit(session, commit=commit_str) + if existing is not None: + abort_with_error(409, "Commit '%s' already exists" % commit_str) + + metadata = _extract_commit_fields(data, ts) + commit_obj = ts.get_or_create_commit(session, commit_str, **metadata) + + # Set ordinal if provided. + ordinal = data.get('ordinal') + if ordinal is not None: + ts.update_commit(session, commit_obj, ordinal=ordinal) + + session.flush() + + result = _serialize_commit_detail(commit_obj, testsuite, ts, session) + resp = jsonify(result) + resp.status_code = 201 + return resp + + +@blp.route('/commits/') +class CommitDetail(MethodView): + """Commit detail, update, and delete.""" + + @require_scope('read') + @blp.arguments(CommitDetailQuerySchema, location="query") + @blp.response(200, CommitDetailSchema) + def get(self, query_args, testsuite, commit_value): + """Get commit detail by commit string. + + The response includes previous_commit and next_commit references + (based on ordinal ordering). + """ + reject_unknown_params(set()) + ts = g.ts + session = g.db_session + + commit_obj = ts.get_commit(session, commit=commit_value) + if commit_obj is None: + abort_with_error(404, "Commit '%s' not found" % commit_value) + + data = _serialize_commit_detail(commit_obj, testsuite, ts, session) + return add_etag_to_response(jsonify(data), data) + + @require_scope('manage') + @blp.response(200, CommitDetailSchema) + def patch(self, testsuite, commit_value): + """Update commit ordinal and/or commit_fields.""" + ts = g.ts + session = g.db_session + + commit_obj = ts.get_commit(session, commit=commit_value) + if commit_obj is None: + abort_with_error(404, "Commit '%s' not found" % commit_value) + + data = request.get_json(silent=True) + if not data: + abort_with_error(400, "Request body must be valid JSON") + + # Update ordinal if provided. + if 'ordinal' in data: + ordinal_val = data['ordinal'] + if ordinal_val is None: + ts.update_commit(session, commit_obj, clear_ordinal=True) + else: + ts.update_commit(session, commit_obj, ordinal=ordinal_val) + + # Update commit_fields. + field_updates = _extract_commit_fields(data, ts, skip=('ordinal',)) + if field_updates: + ts.update_commit(session, commit_obj, **field_updates) + + try: + session.flush() + except Exception as exc: + session.rollback() + abort_with_error( + 409, "Failed to update commit: %s" % exc) + + return jsonify( + _serialize_commit_detail(commit_obj, testsuite, ts, session)) + + @require_scope('manage') + @blp.response(204) + def delete(self, testsuite, commit_value): + """Delete a commit and cascade to its runs/samples. + + Returns 409 if FieldChanges reference this commit. + """ + ts = g.ts + session = g.db_session + + commit_obj = ts.get_commit(session, commit=commit_value) + if commit_obj is None: + abort_with_error(404, "Commit '%s' not found" % commit_value) + + try: + ts.delete_commit(session, commit_obj.id) + except ValueError as exc: + abort_with_error(409, str(exc)) + + session.flush() + return '', 204 diff --git a/lnt/server/api/v5/endpoints/orders.py b/lnt/server/api/v5/endpoints/orders.py deleted file mode 100644 index 42bd09ed2..000000000 --- a/lnt/server/api/v5/endpoints/orders.py +++ /dev/null @@ -1,249 +0,0 @@ -"""Order endpoints for the v5 API. - -GET /api/v5/{ts}/orders -- List orders (cursor-paginated) -POST /api/v5/{ts}/orders -- Create order -GET /api/v5/{ts}/orders/{order_value} -- Order detail (includes prev/next) -PATCH /api/v5/{ts}/orders/{order_value} -- Update order metadata -DELETE /api/v5/{ts}/orders/{order_value} -- Not allowed (405) -""" - -from flask import g, jsonify, request -from flask.views import MethodView -from flask_smorest import Blueprint - -from ..auth import require_scope -from ..errors import abort_with_error, reject_unknown_params -from ..etag import add_etag_to_response -from ..helpers import escape_like, validate_tag -from ..pagination import ( - cursor_paginate, - make_paginated_response, -) -from ..schemas.orders import ( - OrderDetailQuerySchema, - OrderDetailSchema, - OrderListQuerySchema, - PaginatedOrderResponseSchema, -) - -blp = Blueprint( - 'Orders', - __name__, - url_prefix='/api/v5/', - description='List, create, and inspect orders (revisions) with previous/next navigation', -) - - -# --------------------------------------------------------------------------- -# Helpers -# --------------------------------------------------------------------------- - -def _serialize_order_fields(order, ts): - """Return a dict of {field_name: value} for the given order.""" - result = {} - for field in ts.order_fields: - val = order.get_field(field) - if val is not None: - result[field.name] = str(val) - return result - - -def _serialize_order_summary(order, ts): - """Serialize an order for list responses.""" - return { - 'fields': _serialize_order_fields(order, ts), - 'tag': order.tag, - } - - -def _order_detail_url(testsuite, order, ts): - """Build the detail URL for an order using its primary field value.""" - primary_field = ts.order_fields[0] - primary_value = order.get_field(primary_field) - return '/api/v5/%s/orders/%s' % (testsuite, primary_value) - - -def _serialize_order_neighbor(order, testsuite, ts): - """Serialize a previous/next order reference, or None.""" - if order is None: - return None - return { - 'fields': _serialize_order_fields(order, ts), - 'link': _order_detail_url(testsuite, order, ts), - } - - -def _serialize_order_detail(order, testsuite, ts): - """Serialize an order for detail responses, including prev/next.""" - return { - 'fields': _serialize_order_fields(order, ts), - 'tag': order.tag, - 'previous_order': _serialize_order_neighbor( - order.previous_order, testsuite, ts), - 'next_order': _serialize_order_neighbor( - order.next_order, testsuite, ts), - } - - -def _lookup_order_by_value(session, ts, order_value): - """Look up an order by its primary field value and optional extra - query parameters for multi-field orders. - - Returns the Order instance. Aborts with 404 or 409 as appropriate. - """ - primary_field = ts.order_fields[0] - query = session.query(ts.Order).filter( - primary_field.column == order_value - ) - - # For multi-field orders, use additional query parameters to - # disambiguate. - if len(ts.order_fields) > 1: - for field in ts.order_fields[1:]: - extra_value = request.args.get(field.name) - if extra_value is not None: - query = query.filter(field.column == extra_value) - - orders = query.all() - - if len(orders) == 0: - abort_with_error(404, "Order '%s' not found" % order_value) - elif len(orders) > 1: - field_names = ', '.join(f.name for f in ts.order_fields[1:]) - abort_with_error( - 409, - "Multiple orders match '%s'. Disambiguate with query " - "parameters: %s" % (order_value, field_names)) - - return orders[0] - - -# --------------------------------------------------------------------------- -# Endpoints -# --------------------------------------------------------------------------- - -@blp.route('/orders') -class OrderList(MethodView): - """List and create orders.""" - - @require_scope('read') - @blp.arguments(OrderListQuerySchema, location="query") - @blp.response(200, PaginatedOrderResponseSchema) - def get(self, query_args, testsuite): - """List orders (cursor-paginated).""" - reject_unknown_params({'cursor', 'limit', 'tag', 'tag_prefix'}) - ts = g.ts - session = g.db_session - - query = session.query(ts.Order) - - # Filter by tag - tag_value = query_args.get('tag') - if tag_value: - query = query.filter(ts.Order.tag == tag_value) - - tag_prefix = query_args.get('tag_prefix') - if tag_prefix: - escaped = escape_like(tag_prefix) - query = query.filter( - ts.Order.tag.like(escaped + '%', escape='\\')) - - cursor_str = query_args.get('cursor') - limit = query_args['limit'] - items, next_cursor = cursor_paginate( - query, ts.Order.id, cursor_str, limit) - - serialized = [_serialize_order_summary(o, ts) for o in items] - return jsonify(make_paginated_response(serialized, next_cursor)) - - @require_scope('submit') - @blp.response(201, OrderDetailSchema) - def post(self, testsuite): - """Create an order explicitly.""" - ts = g.ts - session = g.db_session - - data = request.get_json(silent=True) - if not data: - abort_with_error(400, "Request body must be valid JSON") - - # Validate that all order fields are present. - for field in ts.order_fields: - if field.name not in data: - abort_with_error( - 400, - "Missing required order field: '%s'" % field.name) - - # Check if an order with these exact field values already exists. - query = session.query(ts.Order) - for field in ts.order_fields: - query = query.filter(field.column == data[field.name]) - existing = query.first() - if existing is not None: - abort_with_error( - 409, - "An order with these field values already exists") - - # Create the order. Use _getOrCreateOrder which also maintains - # the linked-list (previous/next) ordering. - # - # _getOrCreateOrder expects a dict and pops order field keys from - # it, so we give it a copy. - params_copy = dict(data) - order = ts._getOrCreateOrder(session, params_copy) - - # Set optional tag. - if 'tag' in data: - order.tag = validate_tag(data['tag']) - - session.flush() - - result = _serialize_order_detail(order, testsuite, ts) - resp = jsonify(result) - resp.status_code = 201 - return resp - - -@blp.route('/orders/') -class OrderDetail(MethodView): - """Order detail, update, and (disallowed) delete.""" - - @require_scope('read') - @blp.arguments(OrderDetailQuerySchema, location="query") - @blp.response(200, OrderDetailSchema) - def get(self, query_args, testsuite, order_value): - """Get order detail by primary field value. - - The response includes previous_order and next_order references. - For multi-field orders, pass additional query parameters to - disambiguate. - """ - ts = g.ts - # Allow dynamic order field names for disambiguation. - valid = {f.name for f in ts.order_fields[1:]} - reject_unknown_params(valid) - session = g.db_session - order = _lookup_order_by_value(session, ts, order_value) - data = _serialize_order_detail(order, testsuite, ts) - return add_etag_to_response(jsonify(data), data) - - @require_scope('manage') - @blp.response(200, OrderDetailSchema) - def patch(self, testsuite, order_value): - """Update order metadata.""" - ts = g.ts - session = g.db_session - order = _lookup_order_by_value(session, ts, order_value) - - data = request.get_json(silent=True) - if not data: - abort_with_error(400, "Request body must be valid JSON") - - # Update tag if provided. Check key presence to distinguish - # "not provided" from an explicit null (which clears the tag). - if 'tag' in data: - order.tag = validate_tag(data['tag']) - - session.flush() - - return jsonify(_serialize_order_detail(order, testsuite, ts)) diff --git a/tests/server/api/v5/test_commits.py b/tests/server/api/v5/test_commits.py new file mode 100644 index 000000000..99f2a8935 --- /dev/null +++ b/tests/server/api/v5/test_commits.py @@ -0,0 +1,649 @@ +# Tests for the v5 commit endpoints. +# +# RUN: rm -rf %t.instance %t.pg.log +# RUN: %{utils}/with_postgres.sh %t.pg.log \ +# RUN: %{utils}/with_temporary_instance.py --db-version 5.0 %t.instance \ +# RUN: -- python %s %t.instance +# END. + +import sys +import os +import unittest +import uuid + +sys.path.insert(0, os.path.dirname(__file__)) +from v5_test_helpers import ( + create_app, create_client, admin_headers, make_scoped_headers, + create_commit, collect_all_pages, +) + + +TS = 'nts' +PREFIX = f'/api/v5/{TS}' + + +class TestCommitList(unittest.TestCase): + """Tests for GET /api/v5/{ts}/commits.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_list_returns_200(self): + """GET /commits returns 200.""" + resp = self.client.get(PREFIX + '/commits') + self.assertEqual(resp.status_code, 200) + + def test_list_has_pagination_envelope(self): + """Response includes cursor pagination envelope.""" + resp = self.client.get(PREFIX + '/commits') + data = resp.get_json() + self.assertIn('items', data) + self.assertIn('cursor', data) + self.assertIn('next', data['cursor']) + self.assertIn('previous', data['cursor']) + + def test_list_returns_commits(self): + """Create a commit via DB and verify it appears in the list.""" + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + rev = f'list-{uuid.uuid4().hex[:8]}' + create_commit(session, ts, commit=rev) + session.commit() + session.close() + + resp = self.client.get(PREFIX + '/commits') + data = resp.get_json() + self.assertGreater(len(data['items']), 0) + for item in data['items']: + self.assertIn('commit', item) + self.assertIn('ordinal', item) + self.assertIn('fields', item) + self.assertIsInstance(item['fields'], dict) + + def test_list_pagination(self): + """Verify cursor pagination works.""" + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + for i in range(3): + create_commit( + session, ts, + commit=f'page-{uuid.uuid4().hex[:6]}-{i}') + session.commit() + session.close() + + resp = self.client.get(PREFIX + '/commits?limit=1') + data = resp.get_json() + self.assertEqual(len(data['items']), 1) + self.assertIsNotNone(data['cursor']['next']) + + cursor = data['cursor']['next'] + resp2 = self.client.get( + PREFIX + f'/commits?limit=1&cursor={cursor}') + self.assertEqual(resp2.status_code, 200) + data2 = resp2.get_json() + self.assertEqual(len(data2['items']), 1) + + def test_invalid_cursor_returns_400(self): + """An invalid cursor string should return 400.""" + resp = self.client.get( + PREFIX + '/commits?cursor=not-a-valid-cursor!!!') + self.assertEqual(resp.status_code, 400) + + +class TestCommitSearch(unittest.TestCase): + """Tests for the search parameter on GET /commits.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_search_by_commit_prefix(self): + """Search by commit string prefix.""" + unique = uuid.uuid4().hex[:8] + prefix = f'srch-{unique}' + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + create_commit(session, ts, commit=f'{prefix}-aaa') + create_commit(session, ts, commit=f'{prefix}-bbb') + create_commit(session, ts, commit=f'other-{uuid.uuid4().hex[:8]}') + session.commit() + session.close() + + resp = self.client.get(PREFIX + f'/commits?search={prefix}') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertEqual(len(data['items']), 2) + for item in data['items']: + self.assertTrue(item['commit'].startswith(prefix)) + + def test_search_no_match(self): + """Search with no matches returns empty list.""" + resp = self.client.get( + PREFIX + '/commits?search=nonexistent-prefix-xyz') + self.assertEqual(resp.status_code, 200) + self.assertEqual(len(resp.get_json()['items']), 0) + + +class TestCommitCreate(unittest.TestCase): + """Tests for POST /api/v5/{ts}/commits.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_create_commit(self): + """Create a commit and verify 201 response.""" + rev = f'create-{uuid.uuid4().hex[:8]}' + resp = self.client.post( + PREFIX + '/commits', + json={'commit': rev}, + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 201) + data = resp.get_json() + self.assertEqual(data['commit'], rev) + self.assertIsNone(data['ordinal']) + + def test_create_commit_with_ordinal(self): + """Create a commit with an explicit ordinal.""" + rev = f'ordinal-{uuid.uuid4().hex[:8]}' + resp = self.client.post( + PREFIX + '/commits', + json={'commit': rev, 'ordinal': 42}, + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 201) + data = resp.get_json() + self.assertEqual(data['ordinal'], 42) + + def test_create_commit_with_fields(self): + """Create a commit with commit_fields metadata.""" + rev = f'fields-{uuid.uuid4().hex[:8]}' + resp = self.client.post( + PREFIX + '/commits', + json={'commit': rev, + 'llvm_project_revision': 'abc123'}, + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 201) + data = resp.get_json() + self.assertEqual(data['fields']['llvm_project_revision'], 'abc123') + + def test_create_commit_includes_prev_next(self): + """Created commit response includes prev/next references.""" + rev = f'prevnext-{uuid.uuid4().hex[:8]}' + resp = self.client.post( + PREFIX + '/commits', + json={'commit': rev}, + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 201) + data = resp.get_json() + self.assertIn('previous_commit', data) + self.assertIn('next_commit', data) + + def test_create_commit_appears_in_list(self): + """Newly created commit appears in the list.""" + rev = f'appear-{uuid.uuid4().hex[:8]}' + self.client.post( + PREFIX + '/commits', + json={'commit': rev}, + headers=admin_headers(), + ) + resp = self.client.get(PREFIX + '/commits') + data = resp.get_json() + commits = [item['commit'] for item in data['items']] + self.assertIn(rev, commits) + + def test_create_duplicate_409(self): + """Creating a commit with a duplicate string returns 409.""" + rev = f'dup-{uuid.uuid4().hex[:8]}' + self.client.post( + PREFIX + '/commits', + json={'commit': rev}, + headers=admin_headers(), + ) + resp = self.client.post( + PREFIX + '/commits', + json={'commit': rev}, + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 409) + + def test_create_missing_commit_400(self): + """Creating without required commit field returns 400.""" + resp = self.client.post( + PREFIX + '/commits', + json={}, + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 400) + + def test_create_no_body_400(self): + """POST without body returns 400.""" + resp = self.client.post( + PREFIX + '/commits', + headers=admin_headers(), + content_type='application/json', + ) + self.assertEqual(resp.status_code, 400) + + def test_create_no_auth_401(self): + """Creating without auth should return 401.""" + resp = self.client.post( + PREFIX + '/commits', + json={'commit': 'no-auth'}, + ) + self.assertEqual(resp.status_code, 401) + + def test_create_read_scope_403(self): + """Creating with read scope should return 403.""" + headers = make_scoped_headers(self.app, 'read') + resp = self.client.post( + PREFIX + '/commits', + json={'commit': 'read-only'}, + headers=headers, + ) + self.assertEqual(resp.status_code, 403) + + def test_create_submit_scope_ok(self): + """Creating with submit scope should succeed.""" + headers = make_scoped_headers(self.app, 'submit') + rev = f'submit-{uuid.uuid4().hex[:8]}' + resp = self.client.post( + PREFIX + '/commits', + json={'commit': rev}, + headers=headers, + ) + self.assertEqual(resp.status_code, 201) + + +class TestCommitDetail(unittest.TestCase): + """Tests for GET /api/v5/{ts}/commits/{value}.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_get_detail(self): + """Get commit detail by commit string.""" + rev = f'detail-{uuid.uuid4().hex[:8]}' + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + create_commit(session, ts, commit=rev) + session.commit() + session.close() + + resp = self.client.get(PREFIX + f'/commits/{rev}') + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertEqual(data['commit'], rev) + self.assertIn('ordinal', data) + self.assertIn('fields', data) + self.assertIn('previous_commit', data) + self.assertIn('next_commit', data) + + def test_get_nonexistent_404(self): + """Getting a nonexistent commit should return 404.""" + resp = self.client.get( + PREFIX + '/commits/nonexistent-commit-xyz') + self.assertEqual(resp.status_code, 404) + + def test_detail_with_neighbors(self): + """Verify prev/next references when neighbors exist.""" + rev1 = f'nbr1-{uuid.uuid4().hex[:8]}' + rev2 = f'nbr2-{uuid.uuid4().hex[:8]}' + rev3 = f'nbr3-{uuid.uuid4().hex[:8]}' + # Create commits with ordinals + self.client.post( + PREFIX + '/commits', + json={'commit': rev1, 'ordinal': 100}, + headers=admin_headers(), + ) + self.client.post( + PREFIX + '/commits', + json={'commit': rev2, 'ordinal': 200}, + headers=admin_headers(), + ) + self.client.post( + PREFIX + '/commits', + json={'commit': rev3, 'ordinal': 300}, + headers=admin_headers(), + ) + + # Middle commit should have both neighbors + resp = self.client.get(PREFIX + f'/commits/{rev2}') + data = resp.get_json() + self.assertIsNotNone(data['previous_commit']) + self.assertIsNotNone(data['next_commit']) + self.assertEqual(data['previous_commit']['commit'], rev1) + self.assertEqual(data['next_commit']['commit'], rev3) + + def test_detail_no_ordinal_no_neighbors(self): + """Commits without ordinal have null neighbors.""" + rev = f'no-ord-{uuid.uuid4().hex[:8]}' + self.client.post( + PREFIX + '/commits', + json={'commit': rev}, + headers=admin_headers(), + ) + resp = self.client.get(PREFIX + f'/commits/{rev}') + data = resp.get_json() + self.assertIsNone(data['previous_commit']) + self.assertIsNone(data['next_commit']) + + +class TestCommitDetailETag(unittest.TestCase): + """ETag tests for GET /api/v5/{ts}/commits/{value}.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_etag_present(self): + """Commit detail response should include an ETag header.""" + rev = f'etag-{uuid.uuid4().hex[:8]}' + self.client.post( + PREFIX + '/commits', + json={'commit': rev}, + headers=admin_headers(), + ) + resp = self.client.get(PREFIX + f'/commits/{rev}') + self.assertEqual(resp.status_code, 200) + self.assertIsNotNone(resp.headers.get('ETag')) + self.assertTrue(resp.headers['ETag'].startswith('W/"')) + + def test_etag_304_on_match(self): + """Sending If-None-Match with the same ETag returns 304.""" + rev = f'etag304-{uuid.uuid4().hex[:8]}' + self.client.post( + PREFIX + '/commits', + json={'commit': rev}, + headers=admin_headers(), + ) + resp = self.client.get(PREFIX + f'/commits/{rev}') + etag = resp.headers['ETag'] + + resp2 = self.client.get( + PREFIX + f'/commits/{rev}', + headers={'If-None-Match': etag}, + ) + self.assertEqual(resp2.status_code, 304) + + def test_etag_200_on_mismatch(self): + """Sending If-None-Match with a different ETag returns 200.""" + rev = f'etag200-{uuid.uuid4().hex[:8]}' + self.client.post( + PREFIX + '/commits', + json={'commit': rev}, + headers=admin_headers(), + ) + resp = self.client.get( + PREFIX + f'/commits/{rev}', + headers={'If-None-Match': 'W/"stale"'}, + ) + self.assertEqual(resp.status_code, 200) + + +class TestCommitUpdate(unittest.TestCase): + """Tests for PATCH /api/v5/{ts}/commits/{value}.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_set_ordinal(self): + """PATCH to set an ordinal on a commit.""" + rev = f'setord-{uuid.uuid4().hex[:8]}' + self.client.post( + PREFIX + '/commits', + json={'commit': rev}, + headers=admin_headers(), + ) + resp = self.client.patch( + PREFIX + f'/commits/{rev}', + json={'ordinal': 9999}, + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 200) + self.assertEqual(resp.get_json()['ordinal'], 9999) + + def test_clear_ordinal(self): + """PATCH with ordinal=null clears the ordinal.""" + rev = f'clrord-{uuid.uuid4().hex[:8]}' + self.client.post( + PREFIX + '/commits', + json={'commit': rev, 'ordinal': 9998}, + headers=admin_headers(), + ) + resp = self.client.patch( + PREFIX + f'/commits/{rev}', + json={'ordinal': None}, + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 200) + self.assertIsNone(resp.get_json()['ordinal']) + + def test_update_commit_field(self): + """PATCH updates a commit field value.""" + rev = f'updfld-{uuid.uuid4().hex[:8]}' + self.client.post( + PREFIX + '/commits', + json={'commit': rev}, + headers=admin_headers(), + ) + resp = self.client.patch( + PREFIX + f'/commits/{rev}', + json={'llvm_project_revision': 'updated123'}, + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 200) + self.assertEqual( + resp.get_json()['fields']['llvm_project_revision'], + 'updated123') + + def test_patch_nonexistent_404(self): + """PATCH nonexistent commit returns 404.""" + resp = self.client.patch( + PREFIX + '/commits/nonexistent-xyz', + json={'ordinal': 1}, + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 404) + + def test_patch_no_auth_401(self): + """PATCH without auth returns 401.""" + rev = f'noauth-{uuid.uuid4().hex[:8]}' + self.client.post( + PREFIX + '/commits', + json={'commit': rev}, + headers=admin_headers(), + ) + resp = self.client.patch( + PREFIX + f'/commits/{rev}', + json={'ordinal': 1}, + ) + self.assertEqual(resp.status_code, 401) + + def test_patch_read_scope_403(self): + """PATCH with read scope returns 403.""" + rev = f'readp-{uuid.uuid4().hex[:8]}' + self.client.post( + PREFIX + '/commits', + json={'commit': rev}, + headers=admin_headers(), + ) + headers = make_scoped_headers(self.app, 'read') + resp = self.client.patch( + PREFIX + f'/commits/{rev}', + json={'ordinal': 1}, + headers=headers, + ) + self.assertEqual(resp.status_code, 403) + + +class TestCommitDelete(unittest.TestCase): + """Tests for DELETE /api/v5/{ts}/commits/{value}.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_delete_commit(self): + """Delete a commit and verify it's gone.""" + rev = f'delc-{uuid.uuid4().hex[:8]}' + self.client.post( + PREFIX + '/commits', + json={'commit': rev}, + headers=admin_headers(), + ) + resp = self.client.delete( + PREFIX + f'/commits/{rev}', + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 204) + + resp = self.client.get(PREFIX + f'/commits/{rev}') + self.assertEqual(resp.status_code, 404) + + def test_delete_nonexistent_404(self): + """Deleting a nonexistent commit should return 404.""" + resp = self.client.delete( + PREFIX + '/commits/nonexistent-del-xyz', + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 404) + + def test_delete_with_fieldchange_409(self): + """Delete a commit referenced by a FieldChange returns 409.""" + from v5_test_helpers import ( + create_machine, create_test, create_fieldchange, + ) + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + + c1 = create_commit(session, ts, + commit=f'fc-start-{uuid.uuid4().hex[:8]}') + c2 = create_commit(session, ts, + commit=f'fc-end-{uuid.uuid4().hex[:8]}') + c1_commit = c1.commit # save before closing session + machine = create_machine( + session, ts, name=f'fc-del-{uuid.uuid4().hex[:8]}') + test = create_test( + session, ts, name=f'fc-del/test/{uuid.uuid4().hex[:8]}') + create_fieldchange(session, ts, c1, c2, machine, test, + 'execution_time') + session.commit() + session.close() + + resp = self.client.delete( + PREFIX + f'/commits/{c1_commit}', + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 409) + + def test_delete_cascades_to_runs(self): + """Deleting a commit cascades to its runs.""" + from v5_test_helpers import create_machine, create_run + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + + c = create_commit(session, ts, + commit=f'casc-{uuid.uuid4().hex[:8]}') + c_commit = c.commit # save before closing session + m = create_machine( + session, ts, name=f'casc-m-{uuid.uuid4().hex[:8]}') + run = create_run(session, ts, m, c) + run_uuid = run.uuid + session.commit() + session.close() + + self.client.delete( + PREFIX + f'/commits/{c_commit}', + headers=admin_headers(), + ) + + # Run should be gone too + resp = self.client.get(PREFIX + f'/runs/{run_uuid}') + self.assertEqual(resp.status_code, 404) + + +class TestCommitPagination(unittest.TestCase): + """Exhaustive cursor pagination tests for GET /commits.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + cls._commits = [] + db = cls.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + for i in range(5): + rev = f'pag-{uuid.uuid4().hex[:8]}-{i}' + create_commit(session, ts, commit=rev) + cls._commits.append(rev) + session.commit() + session.close() + + def _collect_all_pages(self): + url = PREFIX + '/commits?limit=2' + return collect_all_pages(self, self.client, url) + + def test_pagination_collects_all_items(self): + """Paginating through all pages collects all commits.""" + all_items = self._collect_all_pages() + commits = [item['commit'] for item in all_items] + for rev in self._commits: + self.assertIn(rev, commits) + + def test_no_duplicate_items_across_pages(self): + """No duplicate commits across pages.""" + all_items = self._collect_all_pages() + commits = [item['commit'] for item in all_items] + self.assertEqual(len(commits), len(set(commits))) + + +class TestCommitUnknownParams(unittest.TestCase): + """Test that unknown query parameters are rejected with 400.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + + def test_list_unknown_param_returns_400(self): + """Unknown query param on list returns 400.""" + resp = self.client.get(PREFIX + '/commits?bogus=1') + self.assertEqual(resp.status_code, 400) + data = resp.get_json() + self.assertIn('bogus', data['error']['message']) + + def test_detail_unknown_param_returns_400(self): + """Unknown query param on detail returns 400.""" + rev = f'unk-{uuid.uuid4().hex[:8]}' + self.client.post( + PREFIX + '/commits', + json={'commit': rev}, + headers=admin_headers(), + ) + resp = self.client.get(PREFIX + f'/commits/{rev}?bogus=1') + self.assertEqual(resp.status_code, 400) + + +if __name__ == '__main__': + unittest.main(argv=[sys.argv[0]], exit=True) diff --git a/tests/server/api/v5/test_orders.py b/tests/server/api/v5/test_orders.py deleted file mode 100644 index 0ae5bb78c..000000000 --- a/tests/server/api/v5/test_orders.py +++ /dev/null @@ -1,640 +0,0 @@ -# Tests for the v5 order endpoints. -# -# RUN: rm -rf %t.instance %t.pg.log -# RUN: %{utils}/with_postgres.sh %t.pg.log \ -# RUN: %{utils}/with_temporary_instance.py %t.instance \ -# RUN: -- python %s %t.instance -# END. - -import sys -import os -import unittest -import uuid - -sys.path.insert(0, os.path.dirname(__file__)) -from v5_test_helpers import ( - create_app, create_client, admin_headers, make_scoped_headers, - collect_all_pages, -) - - -TS = 'nts' -PREFIX = f'/api/v5/{TS}' - - -class TestOrderList(unittest.TestCase): - """Tests for GET /api/v5/{ts}/orders.""" - @classmethod - def setUpClass(cls): - super().setUpClass() - cls.app = create_app(sys.argv[1]) - cls.client = create_client(cls.app) - - def test_list_returns_200(self): - resp = self.client.get(PREFIX + '/orders') - self.assertEqual(resp.status_code, 200) - - def test_list_has_pagination_envelope(self): - resp = self.client.get(PREFIX + '/orders') - data = resp.get_json() - self.assertIn('items', data) - self.assertIn('cursor', data) - self.assertIn('next', data['cursor']) - self.assertIn('previous', data['cursor']) - - def test_list_returns_orders(self): - """Create an order via the API and verify it appears in the list.""" - rev = f'list-{uuid.uuid4().hex[:8]}' - self.client.post( - PREFIX + '/orders', - json={'llvm_project_revision': rev}, - headers=admin_headers(), - ) - - resp = self.client.get(PREFIX + '/orders') - data = resp.get_json() - self.assertGreater(len(data['items']), 0) - # Each item should have a 'fields' dict - for item in data['items']: - self.assertIn('fields', item) - self.assertIsInstance(item['fields'], dict) - - def test_list_pagination(self): - """Verify cursor pagination works.""" - for i in range(3): - rev = f'page-{uuid.uuid4().hex[:6]}-{i}' - self.client.post( - PREFIX + '/orders', - json={'llvm_project_revision': rev}, - headers=admin_headers(), - ) - - resp = self.client.get(PREFIX + '/orders?limit=1') - data = resp.get_json() - self.assertEqual(len(data['items']), 1) - self.assertIsNotNone(data['cursor']['next']) - - # Follow cursor - cursor = data['cursor']['next'] - resp2 = self.client.get( - PREFIX + f'/orders?limit=1&cursor={cursor}') - self.assertEqual(resp2.status_code, 200) - data2 = resp2.get_json() - self.assertEqual(len(data2['items']), 1) - - def test_list_no_auth_required_for_read(self): - """GET should work without auth headers (unauthenticated reads).""" - resp = self.client.get(PREFIX + '/orders') - self.assertEqual(resp.status_code, 200) - - def test_invalid_cursor_returns_400(self): - """An invalid cursor string should return 400.""" - resp = self.client.get( - PREFIX + '/orders?cursor=not-a-valid-cursor!!!') - self.assertEqual(resp.status_code, 400) - - -class TestOrderCreate(unittest.TestCase): - """Tests for POST /api/v5/{ts}/orders.""" - @classmethod - def setUpClass(cls): - super().setUpClass() - cls.app = create_app(sys.argv[1]) - cls.client = create_client(cls.app) - - def test_create_order(self): - """Create an order and verify 201 response.""" - rev = f'create-{uuid.uuid4().hex[:8]}' - resp = self.client.post( - PREFIX + '/orders', - json={'llvm_project_revision': rev}, - headers=admin_headers(), - ) - self.assertEqual(resp.status_code, 201) - data = resp.get_json() - self.assertIn('fields', data) - self.assertEqual(data['fields']['llvm_project_revision'], rev) - - def test_create_order_includes_prev_next(self): - """Created order response includes prev/next references.""" - rev = f'prevnext-{uuid.uuid4().hex[:8]}' - resp = self.client.post( - PREFIX + '/orders', - json={'llvm_project_revision': rev}, - headers=admin_headers(), - ) - self.assertEqual(resp.status_code, 201) - data = resp.get_json() - # prev/next may be None but the keys should be present - self.assertIn('previous_order', data) - self.assertIn('next_order', data) - - def test_create_order_appears_in_list(self): - """Newly created order appears in the order list.""" - rev = f'appear-{uuid.uuid4().hex[:8]}' - self.client.post( - PREFIX + '/orders', - json={'llvm_project_revision': rev}, - headers=admin_headers(), - ) - resp = self.client.get(PREFIX + '/orders') - data = resp.get_json() - revs = [item['fields'].get('llvm_project_revision') - for item in data['items']] - self.assertIn(rev, revs) - - def test_create_duplicate_409(self): - """Creating an order with duplicate field values returns 409.""" - rev = f'dup-{uuid.uuid4().hex[:8]}' - self.client.post( - PREFIX + '/orders', - json={'llvm_project_revision': rev}, - headers=admin_headers(), - ) - resp = self.client.post( - PREFIX + '/orders', - json={'llvm_project_revision': rev}, - headers=admin_headers(), - ) - self.assertEqual(resp.status_code, 409) - - def test_create_order_missing_field_400(self): - """Creating without required field returns 400.""" - resp = self.client.post( - PREFIX + '/orders', - json={}, - headers=admin_headers(), - ) - self.assertEqual(resp.status_code, 400) - - def test_create_order_no_body_400(self): - """POST without body returns 400.""" - resp = self.client.post( - PREFIX + '/orders', - headers=admin_headers(), - content_type='application/json', - ) - self.assertEqual(resp.status_code, 400) - - def test_create_order_no_auth_401(self): - """Creating without auth should return 401.""" - resp = self.client.post( - PREFIX + '/orders', - json={'llvm_project_revision': 'no-auth'}, - ) - self.assertEqual(resp.status_code, 401) - - def test_create_order_read_scope_403(self): - """Creating with read scope should return 403.""" - headers = make_scoped_headers(self.app, 'read') - resp = self.client.post( - PREFIX + '/orders', - json={'llvm_project_revision': 'read-only'}, - headers=headers, - ) - self.assertEqual(resp.status_code, 403) - - def test_create_order_submit_scope_ok(self): - """Submit scope should be sufficient to create orders.""" - headers = make_scoped_headers(self.app, 'submit') - rev = f'submit-{uuid.uuid4().hex[:8]}' - resp = self.client.post( - PREFIX + '/orders', - json={'llvm_project_revision': rev}, - headers=headers, - ) - self.assertEqual(resp.status_code, 201) - - -class TestOrderDetail(unittest.TestCase): - """Tests for GET /api/v5/{ts}/orders/{order_value}.""" - @classmethod - def setUpClass(cls): - super().setUpClass() - cls.app = create_app(sys.argv[1]) - cls.client = create_client(cls.app) - - def test_get_order_detail(self): - """Get order detail by primary field value.""" - rev = f'detail-{uuid.uuid4().hex[:8]}' - self.client.post( - PREFIX + '/orders', - json={'llvm_project_revision': rev}, - headers=admin_headers(), - ) - - resp = self.client.get(PREFIX + f'/orders/{rev}') - self.assertEqual(resp.status_code, 200) - data = resp.get_json() - self.assertIn('fields', data) - self.assertEqual(data['fields']['llvm_project_revision'], rev) - - def test_get_order_includes_prev_next(self): - """Order detail includes previous_order and next_order.""" - rev = f'detail-pn-{uuid.uuid4().hex[:8]}' - self.client.post( - PREFIX + '/orders', - json={'llvm_project_revision': rev}, - headers=admin_headers(), - ) - - resp = self.client.get(PREFIX + f'/orders/{rev}') - data = resp.get_json() - self.assertIn('previous_order', data) - self.assertIn('next_order', data) - - def test_get_nonexistent_404(self): - """Getting a nonexistent order should return 404.""" - resp = self.client.get( - PREFIX + '/orders/nonexistent-order-xyz') - self.assertEqual(resp.status_code, 404) - - def test_order_detail_with_neighbors(self): - """Verify previous/next order references when neighbors exist.""" - # Create two orders via POST so the linked list is maintained - rev1 = f'100{uuid.uuid4().hex[:4]}' - rev2 = f'200{uuid.uuid4().hex[:4]}' - self.client.post( - PREFIX + '/orders', - json={'llvm_project_revision': rev1}, - headers=admin_headers(), - ) - self.client.post( - PREFIX + '/orders', - json={'llvm_project_revision': rev2}, - headers=admin_headers(), - ) - - # At least one of them should have a neighbor - resp1 = self.client.get(PREFIX + f'/orders/{rev1}') - resp2 = self.client.get(PREFIX + f'/orders/{rev2}') - data1 = resp1.get_json() - data2 = resp2.get_json() - - # We can't predict exact ordering, but the response structure - # should be correct - for data in (data1, data2): - self.assertIn('previous_order', data) - self.assertIn('next_order', data) - for neighbor_key in ('previous_order', 'next_order'): - neighbor = data[neighbor_key] - if neighbor is not None: - self.assertIn('fields', neighbor) - self.assertIn('link', neighbor) - - -class TestOrderDetailETag(unittest.TestCase): - """ETag tests for GET /api/v5/{ts}/orders/{order_value}.""" - @classmethod - def setUpClass(cls): - super().setUpClass() - cls.app = create_app(sys.argv[1]) - cls.client = create_client(cls.app) - - def test_etag_present_on_detail(self): - """Order detail response should include an ETag header.""" - rev = f'etag-present-{uuid.uuid4().hex[:8]}' - self.client.post( - PREFIX + '/orders', - json={'llvm_project_revision': rev}, - headers=admin_headers(), - ) - resp = self.client.get(PREFIX + f'/orders/{rev}') - self.assertEqual(resp.status_code, 200) - etag = resp.headers.get('ETag') - self.assertIsNotNone(etag) - self.assertTrue(etag.startswith('W/"')) - - def test_etag_304_on_match(self): - """Sending If-None-Match with the same ETag returns 304.""" - rev = f'etag-304-{uuid.uuid4().hex[:8]}' - self.client.post( - PREFIX + '/orders', - json={'llvm_project_revision': rev}, - headers=admin_headers(), - ) - resp = self.client.get(PREFIX + f'/orders/{rev}') - etag = resp.headers.get('ETag') - - resp2 = self.client.get( - PREFIX + f'/orders/{rev}', - headers={'If-None-Match': etag}, - ) - self.assertEqual(resp2.status_code, 304) - - def test_etag_200_on_mismatch(self): - """Sending If-None-Match with a different ETag returns 200.""" - rev = f'etag-200-{uuid.uuid4().hex[:8]}' - self.client.post( - PREFIX + '/orders', - json={'llvm_project_revision': rev}, - headers=admin_headers(), - ) - resp = self.client.get( - PREFIX + f'/orders/{rev}', - headers={'If-None-Match': 'W/"stale-etag-value"'}, - ) - self.assertEqual(resp.status_code, 200) - self.assertIsNotNone(resp.get_json()) - - -class TestOrderUpdate(unittest.TestCase): - """Tests for PATCH /api/v5/{ts}/orders/{order_value}.""" - @classmethod - def setUpClass(cls): - super().setUpClass() - cls.app = create_app(sys.argv[1]) - cls.client = create_client(cls.app) - - def test_patch_order(self): - """PATCH an existing order (currently limited, just confirms 200).""" - rev = f'patch-{uuid.uuid4().hex[:8]}' - self.client.post( - PREFIX + '/orders', - json={'llvm_project_revision': rev}, - headers=admin_headers(), - ) - resp = self.client.patch( - PREFIX + f'/orders/{rev}', - json={'note': 'test'}, - headers=admin_headers(), - ) - self.assertEqual(resp.status_code, 200) - - def test_patch_nonexistent_404(self): - """PATCHing a nonexistent order returns 404.""" - resp = self.client.patch( - PREFIX + '/orders/nonexistent-patch-xyz', - json={'note': 'test'}, - headers=admin_headers(), - ) - self.assertEqual(resp.status_code, 404) - - def test_patch_no_auth_401(self): - """PATCH without auth returns 401.""" - rev = f'patch-noauth-{uuid.uuid4().hex[:8]}' - self.client.post( - PREFIX + '/orders', - json={'llvm_project_revision': rev}, - headers=admin_headers(), - ) - resp = self.client.patch( - PREFIX + f'/orders/{rev}', - json={'note': 'test'}, - ) - self.assertEqual(resp.status_code, 401) - - def test_patch_read_scope_403(self): - """PATCH with read scope returns 403.""" - rev = f'patch-read-{uuid.uuid4().hex[:8]}' - self.client.post( - PREFIX + '/orders', - json={'llvm_project_revision': rev}, - headers=admin_headers(), - ) - headers = make_scoped_headers(self.app, 'read') - resp = self.client.patch( - PREFIX + f'/orders/{rev}', - json={'note': 'test'}, - headers=headers, - ) - self.assertEqual(resp.status_code, 403) - - -class TestOrderPagination(unittest.TestCase): - """Exhaustive cursor pagination tests for GET /api/v5/{ts}/orders.""" - @classmethod - def setUpClass(cls): - super().setUpClass() - cls.app = create_app(sys.argv[1]) - cls.client = create_client(cls.app) - cls._revisions = [] - for i in range(5): - rev = f'pag-{uuid.uuid4().hex[:8]}-{i}' - cls.client.post( - PREFIX + '/orders', - json={'llvm_project_revision': rev}, - headers=admin_headers(), - ) - cls._revisions.append(rev) - - def _collect_all_pages(self): - url = PREFIX + '/orders?limit=2' - return collect_all_pages(self, self.client, url) - - def test_pagination_collects_all_items(self): - """Paginating through all pages collects all created orders.""" - all_items = self._collect_all_pages() - revisions = [item['fields']['llvm_project_revision'] - for item in all_items] - for rev in self._revisions: - self.assertIn(rev, revisions) - - def test_no_duplicate_items_across_pages(self): - """No duplicate orders across pages.""" - all_items = self._collect_all_pages() - revisions = [item['fields']['llvm_project_revision'] - for item in all_items] - self.assertEqual(len(revisions), len(set(revisions))) - - -class TestOrderUnknownParams(unittest.TestCase): - """Test that unknown query parameters are rejected with 400.""" - @classmethod - def setUpClass(cls): - super().setUpClass() - cls.app = create_app(sys.argv[1]) - cls.client = create_client(cls.app) - - def test_orders_list_unknown_param_returns_400(self): - resp = self.client.get(PREFIX + '/orders?bogus=1') - self.assertEqual(resp.status_code, 400) - data = resp.get_json() - self.assertIn('bogus', data['error']['message']) - - def test_order_detail_unknown_param_returns_400(self): - rev = f'unk-det-{uuid.uuid4().hex[:8]}' - self.client.post( - PREFIX + '/orders', - json={'llvm_project_revision': rev}, - headers=admin_headers(), - ) - resp = self.client.get(PREFIX + f'/orders/{rev}?bogus=1') - self.assertEqual(resp.status_code, 400) - - -class TestOrderTag(unittest.TestCase): - """Tests for order tagging (tag field on orders).""" - @classmethod - def setUpClass(cls): - super().setUpClass() - cls.app = create_app(sys.argv[1]) - cls.client = create_client(cls.app) - - def _create_order(self, rev=None, tag=None): - """Helper to create an order, optionally with a tag.""" - if rev is None: - rev = f'tag-{uuid.uuid4().hex[:8]}' - body = {'llvm_project_revision': rev} - if tag is not None: - body['tag'] = tag - resp = self.client.post( - PREFIX + '/orders', - json=body, - headers=admin_headers(), - ) - return resp, rev - - def test_tag_on_create(self): - """POST /orders with tag field sets the tag.""" - resp, rev = self._create_order(tag='release-18.1') - self.assertEqual(resp.status_code, 201) - data = resp.get_json() - self.assertEqual(data['tag'], 'release-18.1') - - def test_tag_appears_in_detail(self): - """Tag appears in GET /orders/{value} detail.""" - _, rev = self._create_order(tag='detail-tag') - resp = self.client.get(PREFIX + f'/orders/{rev}') - self.assertEqual(resp.status_code, 200) - self.assertEqual(resp.get_json()['tag'], 'detail-tag') - - def test_tag_appears_in_list(self): - """Tag appears in GET /orders list items.""" - _, rev = self._create_order(tag='list-tag') - resp = self.client.get(PREFIX + '/orders?tag=list-tag') - self.assertEqual(resp.status_code, 200) - data = resp.get_json() - self.assertGreater(len(data['items']), 0) - self.assertEqual(data['items'][0]['tag'], 'list-tag') - - def test_tag_default_null(self): - """Orders created without a tag have tag=null.""" - resp, rev = self._create_order() - self.assertEqual(resp.status_code, 201) - self.assertIsNone(resp.get_json()['tag']) - - def test_set_tag_via_patch(self): - """PATCH to set a tag on an existing order.""" - _, rev = self._create_order() - resp = self.client.patch( - PREFIX + f'/orders/{rev}', - json={'tag': 'patched'}, - headers=admin_headers(), - ) - self.assertEqual(resp.status_code, 200) - self.assertEqual(resp.get_json()['tag'], 'patched') - - # Verify it persists - detail = self.client.get(PREFIX + f'/orders/{rev}') - self.assertEqual(detail.get_json()['tag'], 'patched') - - def test_clear_tag_via_patch(self): - """PATCH {"tag": null} clears the tag.""" - _, rev = self._create_order(tag='to-clear') - resp = self.client.patch( - PREFIX + f'/orders/{rev}', - json={'tag': None}, - headers=admin_headers(), - ) - self.assertEqual(resp.status_code, 200) - self.assertIsNone(resp.get_json()['tag']) - - def test_tag_too_long_on_patch_400(self): - """PATCH with >64 char tag returns 400.""" - _, rev = self._create_order() - resp = self.client.patch( - PREFIX + f'/orders/{rev}', - json={'tag': 'x' * 65}, - headers=admin_headers(), - ) - self.assertEqual(resp.status_code, 400) - - def test_tag_too_long_on_create_400(self): - """POST /orders with >64 char tag returns 400.""" - rev = f'tag-long-{uuid.uuid4().hex[:8]}' - resp = self.client.post( - PREFIX + '/orders', - json={'llvm_project_revision': rev, 'tag': 'x' * 65}, - headers=admin_headers(), - ) - self.assertEqual(resp.status_code, 400) - - def test_filter_by_tag(self): - """Filter orders by exact tag.""" - unique = uuid.uuid4().hex[:8] - tag_a = f'filter-a-{unique}' - tag_b = f'filter-b-{unique}' - self._create_order(tag=tag_a) - self._create_order(tag=tag_b) - - resp = self.client.get(PREFIX + f'/orders?tag={tag_a}') - self.assertEqual(resp.status_code, 200) - data = resp.get_json() - self.assertEqual(len(data['items']), 1) - self.assertEqual(data['items'][0]['tag'], tag_a) - - def test_filter_by_tag_prefix(self): - """Filter orders by tag prefix.""" - unique = uuid.uuid4().hex[:8] - prefix = f'pfx-{unique}' - self._create_order(tag=f'{prefix}-18.1') - self._create_order(tag=f'{prefix}-19.0') - self._create_order(tag='other-tag') - - resp = self.client.get(PREFIX + f'/orders?tag_prefix={prefix}') - self.assertEqual(resp.status_code, 200) - data = resp.get_json() - self.assertEqual(len(data['items']), 2) - for item in data['items']: - self.assertTrue(item['tag'].startswith(prefix)) - - def test_filter_by_nonexistent_tag(self): - """Filtering by a tag that doesn't exist returns empty results.""" - resp = self.client.get( - PREFIX + '/orders?tag=nonexistent-tag-xyz-abc') - self.assertEqual(resp.status_code, 200) - data = resp.get_json() - self.assertEqual(len(data['items']), 0) - - def test_patch_without_tag_preserves_existing(self): - """PATCH with no tag key leaves the existing tag unchanged.""" - _, rev = self._create_order(tag='keep-me') - resp = self.client.patch( - PREFIX + f'/orders/{rev}', - json={'unrelated': 'data'}, - headers=admin_headers(), - ) - self.assertEqual(resp.status_code, 200) - self.assertEqual(resp.get_json()['tag'], 'keep-me') - - def test_non_string_tag_on_create_400(self): - """POST /orders with a non-string tag returns 400.""" - rev = f'tag-int-{uuid.uuid4().hex[:8]}' - resp = self.client.post( - PREFIX + '/orders', - json={'llvm_project_revision': rev, 'tag': 42}, - headers=admin_headers(), - ) - self.assertEqual(resp.status_code, 400) - - def test_non_string_tag_on_patch_400(self): - """PATCH with a non-string tag returns 400.""" - _, rev = self._create_order() - resp = self.client.patch( - PREFIX + f'/orders/{rev}', - json={'tag': ['not', 'a', 'string']}, - headers=admin_headers(), - ) - self.assertEqual(resp.status_code, 400) - - def test_tag_exactly_64_chars_accepted(self): - """A tag with exactly 64 characters is accepted.""" - tag = 'x' * 64 - resp, rev = self._create_order(tag=tag) - self.assertEqual(resp.status_code, 201) - self.assertEqual(resp.get_json()['tag'], tag) - - -if __name__ == '__main__': - unittest.main(argv=[sys.argv[0]], exit=True) From a54227061d14ed417fc3b6bc8339d9d36fa5cc67 Mon Sep 17 00:00:00 2001 From: Louis Dionne Date: Mon, 13 Apr 2026 21:38:17 -0400 Subject: [PATCH 044/143] [API] Rewrite trends endpoint for v5 DB MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Delegate geomean aggregation to V5TestSuiteDB.query_trends() instead of inline SQL. Response: order dict → commit string + ordinal, timestamp → submitted_at for consistency. Drop v4 status_field filtering (v5 has no status_field concept; query_trends already filters metric > 0). Reject non-numeric (status/hash) metrics. Tests rewritten to use direct DB helpers for timestamp control (submit_run no longer accepts start_time/end_time). Co-Authored-By: Claude Opus 4.6 (1M context) --- docs/design/v5-api.md | 4 +- docs/v5-api-implementation-plan.md | 6 +- docs/v5-ui-implementation-plan.md | 17 ++- lnt/server/api/v5/endpoints/trends.py | 99 ++++----------- lnt/server/api/v5/schemas/trends.py | 16 +-- lnt/server/db/v5/__init__.py | 21 +++- tests/server/api/v5/test_trends.py | 161 +++++++++++++++---------- tests/server/db/v5/test_time_series.py | 3 +- 8 files changed, 164 insertions(+), 163 deletions(-) diff --git a/docs/design/v5-api.md b/docs/design/v5-api.md index 295ebe2cb..7731c5a3c 100644 --- a/docs/design/v5-api.md +++ b/docs/design/v5-api.md @@ -122,8 +122,8 @@ POST /trends The metric field is required and must be a numeric type (Real or Integer); Status and Hash metrics are rejected with 400. All other fields are optional. Unlike the query endpoint's single machine string, machine accepts a list of names — the Dashboard needs data for multiple machines in one call. Order-based filters are intentionally omitted; the Dashboard uses time-based filtering exclusively. -Returns geomean-aggregated trend data per (machine, order). Not paginated — the result set is bounded by (machines × orders in range), typically < 2000 rows. -Each item contains: machine name, order dict, timestamp (latest run start_time), and geomean value. +Returns geomean-aggregated trend data per (machine, commit). Not paginated — the result set is bounded by (machines × commits in range), typically < 2000 rows. +Each item contains: machine name, commit string, ordinal (nullable), submitted_at (latest run submission time), and geomean value. Geomean is computed in SQL: `exp(avg(ln(positive_values)))`, skipping zero/negative values. Schema and Fields diff --git a/docs/v5-api-implementation-plan.md b/docs/v5-api-implementation-plan.md index ab792a68e..479286594 100644 --- a/docs/v5-api-implementation-plan.md +++ b/docs/v5-api-implementation-plan.md @@ -591,7 +591,7 @@ Body (JSON): {metric, machine, test, order, after_order, before_order, `convert_revision()` for correctness. Apply `after`/`before` filters in Python. Cap SQL query at 10,000 rows as safety limit. - Cursor: encode the last order's field values. On next request, use to resume. -- Response per data point: `{test, machine, metric, value, order: {field: value}, run_uuid, timestamp}` +- Response per data point: `{test, machine, metric, value, commit, ordinal, submitted_at}` - Auth: read only. ### 5.11 Schema and Fields @@ -781,8 +781,8 @@ Each endpoint must test: 29. Trends endpoint (`POST /trends`) — server-side geomean aggregation for Dashboard sparklines - New files: `endpoints/trends.py`, `schemas/trends.py` - Accepts: metric (required), machine (list, optional), after_time/before_time (optional) - - Returns: geomean-aggregated items per (machine, order), not paginated - - SQL-level aggregation: GROUP BY (machine_name, order_id) with exp(avg(ln(value))); Order objects batch-loaded separately + - Returns: geomean-aggregated items per (machine, commit), not paginated + - SQL-level aggregation: GROUP BY (machine_name, commit_id) with exp(avg(ln(value))) - Uses `lookup_machine()` from helpers.py for name resolution (404/409 on error) - `@require_scope('read')`, `Meta.unknown = ma.RAISE` diff --git a/docs/v5-ui-implementation-plan.md b/docs/v5-ui-implementation-plan.md index 26db99271..1231f5390 100644 --- a/docs/v5-ui-implementation-plan.md +++ b/docs/v5-ui-implementation-plan.md @@ -1367,10 +1367,12 @@ Add the new interfaces listed in section 2.1: `OrderDetail`, `OrderNeighbor`, `R Add a `fetchTrends` function that calls the server-side geomean aggregation endpoint: ```typescript +// TODO: update frontend code to match (api.ts still uses old field names) export interface TrendsDataPoint { machine: string; - order: Record; - timestamp: string | null; + commit: string; + ordinal: number | null; + submitted_at: string | null; value: number; } @@ -1414,6 +1416,8 @@ Refactor `computeGeomean()` to call the shared `geomean()` primitive from `utils A lightweight Plotly wrapper for small trend charts: ```typescript +// TODO: update frontend code — SparklineTrace.points uses timestamp, +// but the API now returns submitted_at. export interface SparklineTrace { machine: string; color: string; @@ -1479,16 +1483,17 @@ async function fetchSuiteTrends( afterTime: string, signal: AbortSignal, ): Promise { - // Call POST /api/v5/{suite}/trends — server returns geomean per (machine, order) + // Call POST /api/v5/{suite}/trends — server returns geomean per (machine, commit) const items = await fetchTrends(suite, { metric, machine: machines, afterTime }, signal); // Group API response by machine, build SparklineTrace per machine - const byMachine = new Map>(); + // TODO: update frontend code to match (home.ts still uses old field names) + const byMachine = new Map>(); for (const item of items) { - if (!item.timestamp) continue; + if (!item.submitted_at) continue; let points = byMachine.get(item.machine); if (!points) { points = []; byMachine.set(item.machine, points); } - points.push({ timestamp: item.timestamp, value: item.value }); + points.push({ submitted_at: item.submitted_at, value: item.value }); } const traces: SparklineTrace[] = []; diff --git a/lnt/server/api/v5/endpoints/trends.py b/lnt/server/api/v5/endpoints/trends.py index a39e101d1..ef8b72eb1 100644 --- a/lnt/server/api/v5/endpoints/trends.py +++ b/lnt/server/api/v5/endpoints/trends.py @@ -7,18 +7,13 @@ The metric field is required; all other fields are optional. """ -from sqlalchemy import func - from flask import g, jsonify from flask.views import MethodView from flask_smorest import Blueprint -from lnt.testing import PASS - from ..auth import require_scope from ..errors import abort_with_error -from ..helpers import lookup_machine, parse_datetime, resolve_metric, \ - serialize_order +from ..helpers import get_metric_def, lookup_machine, parse_datetime from ..schemas.trends import TrendsQuerySchema, TrendsResponseSchema blp = Blueprint( @@ -29,64 +24,6 @@ ) -def _compute_trends(session, ts, sample_field, machine_ids, - after_time, before_time): - """Build and execute a trends query, returning geomean-aggregated items. - - Groups all samples by (machine, order) and computes the geometric mean - of positive sample values within each group using SQL-level aggregation: - exp(avg(ln(value))). - """ - q = session.query( - ts.Machine.name, - ts.Order.id, - func.exp(func.avg(func.ln(sample_field.column))), - func.max(ts.Run.start_time), - ).select_from(ts.Sample) \ - .join(ts.Run) \ - .join(ts.Order) \ - .join(ts.Machine, ts.Run.machine_id == ts.Machine.id) \ - .filter(sample_field.column > 0) - - if sample_field.status_field: - q = q.filter( - (sample_field.status_field.column == PASS) | - (sample_field.status_field.column.is_(None)) - ) - - if machine_ids: - q = q.filter(ts.Machine.id.in_(machine_ids)) - if after_time: - q = q.filter(ts.Run.start_time > after_time) - if before_time: - q = q.filter(ts.Run.start_time < before_time) - - q = q.group_by(ts.Machine.name, ts.Order.id) \ - .order_by(ts.Machine.name, func.max(ts.Run.start_time)) - rows = q.all() - - # Batch-load the unique Order objects needed for serialization. - order_ids = {row[1] for row in rows} - orders_by_id = {} - if order_ids: - orders_by_id = { - o.id: o for o in - session.query(ts.Order) - .filter(ts.Order.id.in_(order_ids)).all() - } - - items = [] - for machine_name, order_id, geomean_val, max_time in rows: - items.append({ - 'machine': machine_name, - 'order': serialize_order(orders_by_id.get(order_id)), - 'timestamp': (max_time.isoformat() if max_time else None), - 'value': geomean_val, - }) - - return items - - @blp.route('/trends') class TrendsView(MethodView): """Geomean-aggregated trend data.""" @@ -97,24 +34,21 @@ class TrendsView(MethodView): def post(self, query_args, testsuite): """Query geomean-aggregated trend data. - Returns trend data points grouped by (machine, order) with + Returns trend data points grouped by (machine, commit) with the geometric mean of all positive sample values within each group. """ ts = g.ts session = g.db_session - field_name = query_args['metric'] + metric = query_args['metric'] machine_names = query_args.get('machine', []) - field = resolve_metric(ts, field_name) - - # Geomean only makes sense for numeric metrics. - if field.type.name not in ('Real', 'Integer'): + metric_def = get_metric_def(ts, metric) + if metric_def.type != 'real': abort_with_error( 400, "Metric '%s' has type '%s'; trends requires a " - "numeric metric (Real or Integer)" % (field_name, - field.type.name)) + "'real' type metric" % (metric, metric_def.type)) machine_ids = [] for name in machine_names: @@ -137,7 +71,22 @@ def post(self, query_args, testsuite): abort_with_error( 400, "Invalid before_time format, expected ISO 8601") - items = _compute_trends( - session, ts, field, machine_ids, after_time, before_time) + results = ts.query_trends( + session, metric, + machine_ids=machine_ids or None, + after_time=after_time, + before_time=before_time, + ) - return jsonify({'metric': field_name, 'items': items}) + items = [] + for r in results: + items.append({ + 'machine': r['machine_name'], + 'commit': r['commit'], + 'ordinal': r['ordinal'], + 'value': r['value'], + 'submitted_at': (r['submitted_at'].isoformat() + if r['submitted_at'] else None), + }) + + return jsonify({'metric': metric, 'items': items}) diff --git a/lnt/server/api/v5/schemas/trends.py b/lnt/server/api/v5/schemas/trends.py index d8ec191b7..9f2a2e761 100644 --- a/lnt/server/api/v5/schemas/trends.py +++ b/lnt/server/api/v5/schemas/trends.py @@ -37,18 +37,20 @@ class TrendsItemSchema(BaseSchema): required=True, metadata={'description': 'Name of the machine'}, ) - order = ma.fields.Dict( - keys=ma.fields.String(), - values=ma.fields.String(), + commit = ma.fields.String( required=True, metadata={ - 'description': 'Order field values (e.g. llvm_project_revision)', - 'example': {'llvm_project_revision': 'abc123'}, + 'description': 'Commit string (e.g. revision hash)', + 'example': 'abc123', }, ) - timestamp = ma.fields.String( + ordinal = ma.fields.Integer( allow_none=True, - metadata={'description': 'Run start time (ISO 8601)'}, + metadata={'description': 'Commit ordinal position (may be null)'}, + ) + submitted_at = ma.fields.String( + allow_none=True, + metadata={'description': 'Latest run submission time (ISO 8601)'}, ) value = ma.fields.Float( required=True, diff --git a/lnt/server/db/v5/__init__.py b/lnt/server/db/v5/__init__.py index 610a4ab6b..6bf32d1ae 100644 --- a/lnt/server/db/v5/__init__.py +++ b/lnt/server/db/v5/__init__.py @@ -827,7 +827,9 @@ def query_trends( metric: str, *, machine_ids: list[int] | None = None, - time_range: tuple[datetime.datetime, datetime.datetime] | None = None, + after_time: datetime.datetime | None = None, + before_time: datetime.datetime | None = None, + limit: int | None = None, ) -> list[dict[str, Any]]: """Query geomean-aggregated trend data grouped by (machine, commit). @@ -835,8 +837,11 @@ def query_trends( (machine, commit) pair. Only positive metric values are included (required for ``ln``). + *after_time* / *before_time* filter on ``Run.submitted_at``. + *limit* caps the number of rows returned. + Returns a list of dicts with keys: ``machine_name``, ``commit``, - ``ordinal``, ``value``, ``timestamp``. + ``ordinal``, ``value``, ``submitted_at``. """ from sqlalchemy import func @@ -863,10 +868,11 @@ def query_trends( if machine_ids: q = q.filter(self.Machine.id.in_(machine_ids)) - if time_range is not None: - start, end = time_range - q = q.filter(self.Run.submitted_at >= start) - q = q.filter(self.Run.submitted_at <= end) + if after_time is not None: + q = q.filter(self.Run.submitted_at >= after_time) + + if before_time is not None: + q = q.filter(self.Run.submitted_at <= before_time) q = q.group_by( self.Machine.name, self.Commit.id, @@ -881,6 +887,9 @@ def query_trends( self.Commit.id, ) + if limit is not None: + q = q.limit(limit) + results = [] for row in q.all(): results.append({ diff --git a/tests/server/api/v5/test_trends.py b/tests/server/api/v5/test_trends.py index e264e40d3..b78e2e865 100644 --- a/tests/server/api/v5/test_trends.py +++ b/tests/server/api/v5/test_trends.py @@ -2,10 +2,11 @@ # # RUN: rm -rf %t.instance %t.pg.log # RUN: %{utils}/with_postgres.sh %t.pg.log \ -# RUN: %{utils}/with_temporary_instance.py %t.instance \ +# RUN: %{utils}/with_temporary_instance.py --db-version 5.0 %t.instance \ # RUN: -- python %s %t.instance # END. +import datetime import sys import os import unittest @@ -13,16 +14,20 @@ sys.path.insert(0, os.path.dirname(__file__)) from v5_test_helpers import ( - create_app, create_client, submit_run, + create_app, create_client, + create_machine, create_commit, create_run, + create_test, create_sample, ) TS = 'nts' PREFIX = f'/api/v5/{TS}' -def _setup_trends_data(client, unique=None): +def _setup_trends_data(app, unique=None): """Create two machines, two tests, and several runs with samples. + Uses direct DB helpers for timestamp control. + Returns a dict with metadata for assertions. """ if unique is None: @@ -33,22 +38,38 @@ def _setup_trends_data(client, unique=None): test1_name = f'trends-t1/{unique}' test2_name = f'trends-t2/{unique}' - # Machine A: 3 orders, each with 2 tests - # Order 100: test1=4.0, test2=16.0 -> geomean = 8.0 - # Order 101: test1=9.0, test2=9.0 -> geomean = 9.0 - # Order 102: test1=1.0, test2=100.0 -> geomean = 10.0 + db = app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + + machine_a = create_machine(session, ts, name=machine_a_name) + machine_b = create_machine(session, ts, name=machine_b_name) + test1 = create_test(session, ts, name=test1_name) + test2 = create_test(session, ts, name=test2_name) + + # Machine A: 3 commits, each with 2 tests + # Commit 100: test1=4.0, test2=16.0 -> geomean = 8.0 + # Commit 101: test1=9.0, test2=9.0 -> geomean = 9.0 + # Commit 102: test1=1.0, test2=100.0 -> geomean = 10.0 for i, (v1, v2) in enumerate([(4.0, 16.0), (9.0, 9.0), (1.0, 100.0)]): - submit_run(client, machine_a_name, f'{100 + i}-{unique}', - [{'name': test1_name, 'execution_time': [v1]}, - {'name': test2_name, 'execution_time': [v2]}], - start_time=f'2024-06-0{1 + i}T12:00:00', - end_time=f'2024-06-0{1 + i}T12:30:00') - - # Machine B: 1 order with 1 test (earlier date, outside some time ranges) - submit_run(client, machine_b_name, f'200-{unique}', - [{'name': test1_name, 'execution_time': [25.0]}], - start_time='2024-05-01T12:00:00', - end_time='2024-05-01T12:30:00') + commit = create_commit( + session, ts, commit=f'{100 + i}-{unique}') + run = create_run( + session, ts, machine_a, commit, + submitted_at=datetime.datetime(2024, 6, 1 + i, 12, 0, 0)) + create_sample(session, ts, run, test1, execution_time=v1) + create_sample(session, ts, run, test2, execution_time=v2) + + # Machine B: 1 commit with 1 test (earlier date, outside some time ranges) + commit_b = create_commit( + session, ts, commit=f'200-{unique}') + run_b = create_run( + session, ts, machine_b, commit_b, + submitted_at=datetime.datetime(2024, 5, 1, 12, 0, 0)) + create_sample(session, ts, run_b, test1, execution_time=25.0) + + session.commit() + session.close() return { 'machine_a': machine_a_name, @@ -58,6 +79,33 @@ def _setup_trends_data(client, unique=None): } +def _setup_single_commit(app, *, values, commit_prefix, submitted_at): + """Create a machine with two tests and one commit for edge-case testing. + + *values* is a dict mapping test suffix ('t1', 't2') to sample value. + Returns the machine name. + """ + unique = uuid.uuid4().hex[:8] + machine_name = f'trends-{commit_prefix}-m-{unique}' + + db = app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + + machine = create_machine(session, ts, name=machine_name) + test1 = create_test(session, ts, name=f'trends-{commit_prefix}-t1/{unique}') + test2 = create_test(session, ts, name=f'trends-{commit_prefix}-t2/{unique}') + commit = create_commit(session, ts, commit=f'{commit_prefix}-{unique}') + run = create_run( + session, ts, machine, commit, submitted_at=submitted_at) + create_sample(session, ts, run, test1, execution_time=values['t1']) + create_sample(session, ts, run, test2, execution_time=values['t2']) + + session.commit() + session.close() + return machine_name + + class TestTrendsErrors(unittest.TestCase): """Tests for error responses from the trends endpoint.""" @classmethod @@ -119,7 +167,7 @@ def test_non_numeric_metric_returns_400(self): self.assertEqual(resp.status_code, 400) data = resp.get_json() self.assertIn('error', data) - self.assertIn('numeric', data['error']['message']) + self.assertIn("'real'", data['error']['message']) class TestTrendsValidQuery(unittest.TestCase): @@ -129,7 +177,7 @@ def setUpClass(cls): super().setUpClass() cls.app = create_app(sys.argv[1]) cls.client = create_client(cls.app) - cls._data = _setup_trends_data(cls.client) + cls._data = _setup_trends_data(cls.app) def test_returns_200(self): d = self._data @@ -161,10 +209,11 @@ def test_item_structure(self): self.assertGreater(len(data['items']), 0) item = data['items'][0] self.assertIn('machine', item) - self.assertIn('order', item) - self.assertIn('timestamp', item) + self.assertIn('commit', item) + self.assertIn('ordinal', item) + self.assertIn('submitted_at', item) self.assertIn('value', item) - self.assertIsInstance(item['order'], dict) + self.assertIsInstance(item['commit'], str) def test_geomean_correctness(self): """Verify geomean is computed correctly from known values.""" @@ -177,10 +226,10 @@ def test_geomean_correctness(self): items = data['items'] self.assertEqual(len(items), 3) - # Items should be sorted by timestamp - # Order 100: geomean(4, 16) = 8.0 - # Order 101: geomean(9, 9) = 9.0 - # Order 102: geomean(1, 100) = 10.0 + # Items should be sorted by submitted_at + # Commit 100: geomean(4, 16) = 8.0 + # Commit 101: geomean(9, 9) = 9.0 + # Commit 102: geomean(1, 100) = 10.0 values = [item['value'] for item in items] self.assertAlmostEqual(values[0], 8.0, places=5) self.assertAlmostEqual(values[1], 9.0, places=5) @@ -223,7 +272,7 @@ def test_time_range_filter(self): """after_time/before_time correctly filters results.""" d = self._data # Machine B's data is from 2024-05-01, Machine A from 2024-06-01+ - # Filter to only June — should exclude Machine B + # Filter to only June -- should exclude Machine B resp = self.client.post( PREFIX + '/trends', json={'metric': 'execution_time', @@ -246,8 +295,8 @@ def test_empty_result(self): self.assertEqual(resp.status_code, 200) self.assertEqual(len(data['items']), 0) - def test_sorted_by_machine_then_timestamp(self): - """Items are sorted by machine name ascending, then timestamp.""" + def test_sorted_by_machine_then_submitted_at(self): + """Items are sorted by machine name ascending, then submitted_at.""" d = self._data resp = self.client.post( PREFIX + '/trends', @@ -260,10 +309,10 @@ def test_sorted_by_machine_then_timestamp(self): machine_names = [item['machine'] for item in items] self.assertEqual(machine_names, sorted(machine_names)) - # Within each machine, timestamps should be ascending + # Within each machine, submitted_at should be ascending from itertools import groupby for _, group in groupby(items, key=lambda x: x['machine']): - timestamps = [item['timestamp'] for item in group] + timestamps = [item['submitted_at'] for item in group] self.assertEqual(timestamps, sorted(timestamps)) @@ -274,16 +323,12 @@ def setUpClass(cls): super().setUpClass() cls.app = create_app(sys.argv[1]) cls.client = create_client(cls.app) - - unique = uuid.uuid4().hex[:8] - cls._machine_name = f'trends-edge-m-{unique}' - - # One order with test1=0.0 (should be excluded) and test2=25.0 - submit_run(cls.client, cls._machine_name, f'edge-{unique}', - [{'name': f'trends-edge-t1/{unique}', 'execution_time': [0.0]}, - {'name': f'trends-edge-t2/{unique}', 'execution_time': [25.0]}], - start_time='2024-07-01T12:00:00', - end_time='2024-07-01T12:30:00') + # One commit with test1=0.0 (should be excluded) and test2=25.0 + cls._machine_name = _setup_single_commit( + cls.app, + values={'t1': 0.0, 't2': 25.0}, + commit_prefix='edge', + submitted_at=datetime.datetime(2024, 7, 1, 12, 0, 0)) def test_geomean_excludes_zero_values(self): """Zero values are excluded from the geomean computation.""" @@ -304,16 +349,12 @@ def setUpClass(cls): super().setUpClass() cls.app = create_app(sys.argv[1]) cls.client = create_client(cls.app) - - unique = uuid.uuid4().hex[:8] - cls._machine_name = f'trends-allzero-m-{unique}' - - # Order with all-zero values — should produce no result - submit_run(cls.client, cls._machine_name, f'allzero-{unique}', - [{'name': f'trends-allzero-t1/{unique}', 'execution_time': [0.0]}, - {'name': f'trends-allzero-t2/{unique}', 'execution_time': [0.0]}], - start_time='2024-08-01T12:00:00', - end_time='2024-08-01T12:30:00') + # Commit with all-zero values -- should produce no result + cls._machine_name = _setup_single_commit( + cls.app, + values={'t1': 0.0, 't2': 0.0}, + commit_prefix='allzero', + submitted_at=datetime.datetime(2024, 8, 1, 12, 0, 0)) def test_all_zero_group_excluded(self): """A group where every sample is zero produces no result.""" @@ -333,16 +374,12 @@ def setUpClass(cls): super().setUpClass() cls.app = create_app(sys.argv[1]) cls.client = create_client(cls.app) - - unique = uuid.uuid4().hex[:8] - cls._machine_name = f'trends-neg-m-{unique}' - - # One negative, one positive — geomean should use only the positive - submit_run(cls.client, cls._machine_name, f'neg-{unique}', - [{'name': f'trends-neg-t1/{unique}', 'execution_time': [-5.0]}, - {'name': f'trends-neg-t2/{unique}', 'execution_time': [16.0]}], - start_time='2024-08-02T12:00:00', - end_time='2024-08-02T12:30:00') + # One negative, one positive -- geomean should use only the positive + cls._machine_name = _setup_single_commit( + cls.app, + values={'t1': -5.0, 't2': 16.0}, + commit_prefix='neg', + submitted_at=datetime.datetime(2024, 8, 2, 12, 0, 0)) def test_negative_values_excluded(self): """Negative values are excluded; geomean uses only positive values.""" diff --git a/tests/server/db/v5/test_time_series.py b/tests/server/db/v5/test_time_series.py index 5f959fff7..662d22f6e 100644 --- a/tests/server/db/v5/test_time_series.py +++ b/tests/server/db/v5/test_time_series.py @@ -270,7 +270,6 @@ def test_basic_query_trends(self): def test_query_trends_geomean_value(self): """Verify the geomean is computed correctly for machine_a.""" - import math session = self.Session() results = self.tsdb.query_trends( session, "execution_time", @@ -303,7 +302,7 @@ def test_query_trends_filter_by_time_range(self): end = datetime.datetime(2024, 3, 1, 13, 30, 0) results = self.tsdb.query_trends( session, "execution_time", - time_range=(start, end)) + after_time=start, before_time=end) # Only commits within the time range for machine_a for r in results: self.assertIsNotNone(r["submitted_at"]) From 3160e92f19dde88578e4a71dc1e37f99fbc49151 Mon Sep 17 00:00:00 2001 From: Louis Dionne Date: Mon, 13 Apr 2026 23:50:25 -0400 Subject: [PATCH 045/143] [API] Rewrite field_changes endpoint for v5 DB MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Delegate to V5TestSuiteDB methods (create_field_change, get_field_change, list via session.query). Key changes: - order → commit: start_order/end_order → start_commit/end_commit in schemas, endpoint, and tests - Remove ignore/un-ignore endpoints (v5 has no ChangeIgnore model; design decision D8 says external processes are responsible for filtering irrelevant field changes) - Remove run_uuid from FieldChange (v5 model has no Run FK) - Replace resolve_metric() with validate_metric_name() (field_name is a string column, not an FK to SampleField) - Add joinedload() for eager loading of test, machine, start_commit, end_commit relationships - Remove FieldChangeIgnoreResponseSchema from common.py Tests: 33 tests (was 57 — removed 12 ignore/un-ignore, 3 run_uuid, 1 ignored-exclusion, renamed order→commit in remaining). Uses submit_run() + submit_fieldchange() for API-based data creation (preserving 7b8ac8d decoupling), direct DB helpers only for creating assigned FCs (regressions endpoint not yet rewritten). Docs: Updated design doc and API implementation plan — removed ignore endpoints, order→commit field names, removed run_uuid references. Co-Authored-By: Claude Opus 4.6 (1M context) --- docs/design/v5-api.md | 13 +- docs/v5-api-implementation-plan.md | 28 +- lnt/server/api/v5/endpoints/field_changes.py | 183 +++-------- lnt/server/api/v5/schemas/common.py | 16 - lnt/server/api/v5/schemas/regressions.py | 36 +-- tests/server/api/v5/test_field_changes.py | 322 +++++-------------- 6 files changed, 138 insertions(+), 460 deletions(-) diff --git a/docs/design/v5-api.md b/docs/design/v5-api.md index 7731c5a3c..ba007db56 100644 --- a/docs/design/v5-api.md +++ b/docs/design/v5-api.md @@ -93,17 +93,14 @@ Regression detail response (GET /regressions/{uuid}) includes: - field_change_uuid - test, machine, metric - old_value, new_value - - start_order and end_order (the order field values, not internal IDs) - - run_uuid (the run where the change was detected) + - start_commit and end_commit (commit identity strings) Field Changes (triage) GET /field-changes — List unassigned field changes (cursor-paginated, filterable by machine=, test=, metric=) -POST /field-changes — Create a field change programmatically (references machine, test, metric, and orders by name) -POST /field-changes/{uuid}/ignore — Ignore a field change -DELETE /field-changes/{uuid}/ignore — Un-ignore a field change -Field changes are identified by server-generated UUID (schema migration required). -Creating a field change requires: machine (name), test (name), metric (name), old_value, new_value, start_order, end_order, and optionally run_uuid. All references are resolved by name/value, not internal ID. +POST /field-changes — Create a field change programmatically (references machine, test, metric, and commits by name) +Field changes are identified by server-generated UUID. +Creating a field change requires: machine (name), test (name), metric (name), old_value, new_value, start_commit, end_commit. All references are resolved by name/value, not internal ID. Time Series @@ -167,7 +164,7 @@ R7: Authentication and Authorization - API keys with scopes (each scope includes all scopes above it): - read — all GET endpoints - submit — submit runs (POST /runs), create orders (POST /orders) - - triage — modify regression state/title/bug, ignore/un-ignore field changes, create/merge/split regressions, manage regression indicators + - triage — modify regression state/title/bug, create/merge/split regressions, manage regression indicators - manage — create/update/delete machines; update orders; delete runs - admin — create/revoke API keys - Keys stored hashed in the database diff --git a/docs/v5-api-implementation-plan.md b/docs/v5-api-implementation-plan.md index 479286594..61452b800 100644 --- a/docs/v5-api-implementation-plan.md +++ b/docs/v5-api-implementation-plan.md @@ -225,7 +225,7 @@ paths, and only resolve the testsuite when the URL contains one. |-------|-------|--------| | `read` | 0 | All GET endpoints | | `submit` | 1 | Submit runs (POST /runs) | -| `triage` | 2 | Regression state/title/bug, ignore/un-ignore field changes, create/merge/split regressions | +| `triage` | 2 | Regression state/title/bug, create/merge/split regressions, manage indicators | | `manage` | 3 | Create/update/delete machines, orders; delete runs | | `admin` | 4 | Create/revoke API keys | @@ -511,8 +511,7 @@ DELETE /api/v5/{ts}/regressions/{uuid}/indicators/{fc_uuid} — Remove indicato "field_change_uuid": "...", "test": "...", "machine": "...", "metric": "...", "old_value": 0.5, "new_value": 0.8, - "start_order": "154000", "end_order": "154331", - "run_uuid": "..." + "start_commit": "154000", "end_commit": "154331" } ] } @@ -537,18 +536,15 @@ Auth: read=GET, triage=POST/PATCH/DELETE/merge/split/indicators. ``` GET /api/v5/{ts}/field-changes — List unassigned (cursor-paginated) POST /api/v5/{ts}/field-changes — Create a field change -POST /api/v5/{ts}/field-changes/{uuid}/ignore — Ignore -DELETE /api/v5/{ts}/field-changes/{uuid}/ignore — Un-ignore ``` **Key design decisions:** -- Identified by **UUID** (NOT integer ID). Requires migration. -- "Unassigned" = no RegressionIndicator AND no ChangeIgnore (LEFT JOIN + IS NULL pattern - from regression_views.py line 77-85) -- Filters: `machine=`, `test=`, `field=` -- Ignore: create ChangeIgnore row. 409 if already ignored. -- Un-ignore: delete ChangeIgnore row. 404 if not ignored. -- Auth: read=GET, triage=POST (ignore/un-ignore), submit=POST (create). +- Identified by **UUID**. +- "Unassigned" = no RegressionIndicator (LEFT JOIN + IS NULL pattern). + No ChangeIgnore in v5 — field changes that are not relevant should not + be created (the external process is responsible for filtering). +- Filters: `machine=`, `test=`, `metric=` +- Auth: read=GET, submit=POST (create). **POST /field-changes (create):** - Allows creating a field change programmatically (e.g., from external analysis tools) @@ -558,10 +554,10 @@ DELETE /api/v5/{ts}/field-changes/{uuid}/ignore — Un-ignore - `metric` (string, required) — metric name as defined in the test suite schema - `old_value` (float, required) — previous value - `new_value` (float, required) — new value - - `start_order` (string, required) — primary order field value for the start of the change - - `end_order` (string, required) — primary order field value for the end of the change - - `run_uuid` (string, optional) — UUID of the associated run -- Returns 404 if machine, test, metric, start_order, end_order, or run_uuid cannot be resolved + - `start_commit` (string, required) — commit identity string for the start of the change + - `end_commit` (string, required) — commit identity string for the end of the change +- Returns 404 if machine, test, start_commit, or end_commit cannot be resolved +- Returns 400 if metric is unknown - Server generates a UUID for the new field change - Returns 201 with the serialized field change on success - Auth: `submit` scope required diff --git a/lnt/server/api/v5/endpoints/field_changes.py b/lnt/server/api/v5/endpoints/field_changes.py index 5786f6678..10c95c75e 100644 --- a/lnt/server/api/v5/endpoints/field_changes.py +++ b/lnt/server/api/v5/endpoints/field_changes.py @@ -2,29 +2,26 @@ GET /api/v5/{ts}/field-changes -- List unassigned POST /api/v5/{ts}/field-changes -- Create a field change -POST /api/v5/{ts}/field-changes/{uuid}/ignore -- Ignore a field change -DELETE /api/v5/{ts}/field-changes/{uuid}/ignore -- Un-ignore a field change """ -import uuid as uuid_module - -from flask import g, jsonify, make_response +from flask import g, jsonify from flask.views import MethodView from flask_smorest import Blueprint +from sqlalchemy.orm import joinedload from ..auth import require_scope -from ..errors import abort_with_error, reject_unknown_params +from ..errors import reject_unknown_params from ..helpers import ( - lookup_fieldchange, + lookup_commit, lookup_machine, - resolve_metric, + lookup_test, serialize_fieldchange, + validate_metric_name, ) from ..pagination import ( cursor_paginate, make_paginated_response, ) -from ..schemas.common import FieldChangeIgnoreResponseSchema from ..schemas.regressions import ( FieldChangeCreateSchema, FieldChangeListQuerySchema, @@ -36,7 +33,7 @@ 'Field Changes', __name__, url_prefix='/api/v5/', - description='List, create, and triage significant metric changes between orders', + description='List and create significant metric changes between commits', ) @@ -65,46 +62,43 @@ class FieldChangeList(MethodView): def get(self, query_args, testsuite): """List unassigned field changes (cursor-paginated, filterable). - Returns field changes that have not been assigned to a regression - and have not been ignored. + Returns field changes that have not been assigned to a regression. """ reject_unknown_params({'machine', 'test', 'metric', 'cursor', 'limit'}) ts = g.ts session = g.db_session - # Build query: unassigned field changes - # LEFT JOIN ChangeIgnore, filter IS NULL - # LEFT JOIN RegressionIndicator, filter IS NULL - query = session.query(ts.FieldChange) \ - .outerjoin(ts.ChangeIgnore) \ - .filter(ts.ChangeIgnore.id.is_(None)) \ - .outerjoin(ts.RegressionIndicator) \ + # Unassigned = not linked to any regression via RegressionIndicator. + query = ( + session.query(ts.FieldChange) + .options( + joinedload(ts.FieldChange.test), + joinedload(ts.FieldChange.machine), + joinedload(ts.FieldChange.start_commit), + joinedload(ts.FieldChange.end_commit), + ) + .outerjoin(ts.RegressionIndicator) .filter(ts.RegressionIndicator.id.is_(None)) + ) - # Filter by machine name machine_name = query_args.get('machine') if machine_name: - query = query.join( - ts.Machine, - ts.FieldChange.machine_id == ts.Machine.id - ).filter(ts.Machine.name == machine_name) + machine = lookup_machine(session, ts, machine_name) + query = query.filter( + ts.FieldChange.machine_id == machine.id) - # Filter by test name test_name = query_args.get('test') if test_name: - query = query.join( - ts.Test, - ts.FieldChange.test_id == ts.Test.id - ).filter(ts.Test.name == test_name) + test = lookup_test(session, ts, test_name) + query = query.filter( + ts.FieldChange.test_id == test.id) - # Filter by metric name field_name = query_args.get('metric') if field_name: - matching_field = resolve_metric(ts, field_name) + validate_metric_name(ts, field_name) query = query.filter( - ts.FieldChange.field_id == matching_field.id) + ts.FieldChange.field_name == field_name) - # Order by descending ID (most recent first) via cursor_paginate. cursor_str = query_args.get('cursor') limit = query_args['limit'] items, next_cursor = cursor_paginate( @@ -119,127 +113,24 @@ def get(self, query_args, testsuite): def post(self, body, testsuite): """Create a field change. - References machine, test, metric, and orders by name. + References machine, test, metric, and commits by name. """ ts = g.ts session = g.db_session - # Resolve machine machine = lookup_machine(session, ts, body['machine']) + test = lookup_test(session, ts, body['test']) + validate_metric_name(ts, body['metric']) - # Resolve test - test = session.query(ts.Test).filter( - ts.Test.name == body['test'] - ).first() - if test is None: - abort_with_error( - 404, - "Test '%s' not found" % body['test']) - - # Resolve field - matching_field = resolve_metric(ts, body['metric']) - - # Resolve start_order and end_order via primary order field - primary_field = ts.order_fields[0] - - start_order = session.query(ts.Order).filter( - primary_field.column == body['start_order'] - ).first() - if start_order is None: - abort_with_error( - 404, - "Start order '%s' not found" % body['start_order']) - - end_order = session.query(ts.Order).filter( - primary_field.column == body['end_order'] - ).first() - if end_order is None: - abort_with_error( - 404, - "End order '%s' not found" % body['end_order']) - - # Resolve optional run_uuid - run = None - if body.get('run_uuid'): - run = session.query(ts.Run).filter( - ts.Run.uuid == body['run_uuid'] - ).first() - if run is None: - abort_with_error( - 404, - "Run '%s' not found" % body['run_uuid']) - - # Create FieldChange - fc = ts.FieldChange( - start_order=start_order, - end_order=end_order, - machine=machine, - test=test, - field_id=matching_field.id, - ) - fc.uuid = str(uuid_module.uuid4()) - fc.old_value = body['old_value'] - fc.new_value = body['new_value'] - if run is not None: - fc.run = run - session.add(fc) - session.flush() + start_commit = lookup_commit(session, ts, body['start_commit']) + end_commit = lookup_commit(session, ts, body['end_commit']) + + fc = ts.create_field_change( + session, machine, test, body['metric'], + start_commit, end_commit, + body['old_value'], body['new_value']) data = _serialize_fieldchange(fc) resp = jsonify(data) resp.status_code = 201 return resp - - -# --------------------------------------------------------------------------- -# Ignore / Un-ignore -# --------------------------------------------------------------------------- - -@blp.route('/field-changes//ignore') -class FieldChangeIgnore(MethodView): - """Ignore and un-ignore a field change.""" - - @require_scope('triage') - @blp.response(201, FieldChangeIgnoreResponseSchema) - def post(self, testsuite, fc_uuid): - """Ignore a field change. Returns 409 if already ignored.""" - ts = g.ts - session = g.db_session - fc = lookup_fieldchange(session, ts, fc_uuid) - - # Check if already ignored - existing = session.query(ts.ChangeIgnore).filter( - ts.ChangeIgnore.field_change_id == fc.id - ).first() - if existing: - abort_with_error( - 409, "Field change '%s' is already ignored" % fc_uuid) - - ignore = ts.ChangeIgnore(fc) - session.add(ignore) - session.flush() - - resp = jsonify({'status': 'ignored', 'field_change_uuid': fc.uuid}) - resp.status_code = 201 - return resp - - @require_scope('triage') - @blp.response(204) - def delete(self, testsuite, fc_uuid): - """Un-ignore a field change. Returns 404 if not currently ignored.""" - ts = g.ts - session = g.db_session - fc = lookup_fieldchange(session, ts, fc_uuid) - - # Find the ChangeIgnore row - ignore = session.query(ts.ChangeIgnore).filter( - ts.ChangeIgnore.field_change_id == fc.id - ).first() - if ignore is None: - abort_with_error( - 404, "Field change '%s' is not ignored" % fc_uuid) - - session.delete(ignore) - session.flush() - - return make_response('', 204) diff --git a/lnt/server/api/v5/schemas/common.py b/lnt/server/api/v5/schemas/common.py index fb0768579..c709c60f7 100644 --- a/lnt/server/api/v5/schemas/common.py +++ b/lnt/server/api/v5/schemas/common.py @@ -78,22 +78,6 @@ class DiscoveryResponseSchema(BaseSchema): links = ma.fields.Nested(DiscoveryLinksSchema) -# --------------------------------------------------------------------------- -# Field change ignore response schema -# --------------------------------------------------------------------------- - -class FieldChangeIgnoreResponseSchema(BaseSchema): - """Response schema for POST /api/v5/{ts}/field-changes/{uuid}/ignore.""" - status = ma.fields.String( - required=True, - metadata={'description': 'Result status (e.g. "ignored")'}, - ) - field_change_uuid = ma.fields.String( - required=True, - metadata={'description': 'UUID of the ignored field change'}, - ) - - # --------------------------------------------------------------------------- # Query parameter schemas # --------------------------------------------------------------------------- diff --git a/lnt/server/api/v5/schemas/regressions.py b/lnt/server/api/v5/schemas/regressions.py index dc3211213..54b8eee11 100644 --- a/lnt/server/api/v5/schemas/regressions.py +++ b/lnt/server/api/v5/schemas/regressions.py @@ -85,17 +85,13 @@ class IndicatorResponseSchema(BaseSchema): allow_none=True, metadata={'description': 'New value'}, ) - start_order = ma.fields.String( + start_commit = ma.fields.String( allow_none=True, - metadata={'description': 'Start order field value'}, + metadata={'description': 'Start commit identity string'}, ) - end_order = ma.fields.String( + end_commit = ma.fields.String( allow_none=True, - metadata={'description': 'End order field value'}, - ) - run_uuid = ma.fields.String( - allow_none=True, - metadata={'description': 'UUID of the run where the change was detected'}, + metadata={'description': 'End commit identity string'}, ) @@ -125,17 +121,13 @@ class FieldChangeResponseSchema(BaseSchema): allow_none=True, metadata={'description': 'New value'}, ) - start_order = ma.fields.String( - allow_none=True, - metadata={'description': 'Start order field value'}, - ) - end_order = ma.fields.String( + start_commit = ma.fields.String( allow_none=True, - metadata={'description': 'End order field value'}, + metadata={'description': 'Start commit identity string'}, ) - run_uuid = ma.fields.String( + end_commit = ma.fields.String( allow_none=True, - metadata={'description': 'UUID of the run where the change was detected'}, + metadata={'description': 'End commit identity string'}, ) @@ -161,17 +153,13 @@ class FieldChangeCreateSchema(BaseSchema): required=True, metadata={'description': 'New value'}, ) - start_order = ma.fields.String( + start_commit = ma.fields.String( required=True, - metadata={'description': 'Primary order field value for start'}, + metadata={'description': 'Commit identity string for start of change'}, ) - end_order = ma.fields.String( + end_commit = ma.fields.String( required=True, - metadata={'description': 'Primary order field value for end'}, - ) - run_uuid = ma.fields.String( - load_default=None, - metadata={'description': 'Optional UUID of the associated run'}, + metadata={'description': 'Commit identity string for end of change'}, ) diff --git a/tests/server/api/v5/test_field_changes.py b/tests/server/api/v5/test_field_changes.py index 00e0f8d2a..7cdce879c 100644 --- a/tests/server/api/v5/test_field_changes.py +++ b/tests/server/api/v5/test_field_changes.py @@ -2,7 +2,7 @@ # # RUN: rm -rf %t.instance %t.pg.log # RUN: %{utils}/with_postgres.sh %t.pg.log \ -# RUN: %{utils}/with_temporary_instance.py %t.instance \ +# RUN: %{utils}/with_temporary_instance.py --db-version 5.0 %t.instance \ # RUN: -- python %s %t.instance # END. @@ -15,7 +15,9 @@ sys.path.insert(0, os.path.dirname(__file__)) from v5_test_helpers import ( create_app, create_client, make_scoped_headers, admin_headers, - collect_all_pages, submit_run, submit_fieldchange, submit_regression, + collect_all_pages, submit_run, submit_fieldchange, + create_machine, create_commit, create_test, + create_fieldchange, create_regression, ) @@ -27,10 +29,6 @@ def _submit_headers(app): PREFIX = f'/api/v5/{TS}' -def _triage_headers(app): - return make_scoped_headers(app, 'triage') - - def _create_fieldchange_fixture(client, app, prefix='fc', old_value=10.0, new_value=20.0): """Create a machine, two runs, and a field change via the API. @@ -53,26 +51,32 @@ def _create_fieldchange_fixture(client, app, prefix='fc', def _create_unassigned_fieldchange(client, app): - """Create an unassigned, non-ignored field change.""" + """Create an unassigned field change.""" return _create_fieldchange_fixture(client, app) -def _create_assigned_fieldchange(client, app): - """Create a field change assigned to a regression.""" - fc_uuid = _create_fieldchange_fixture(client, app, prefix='fc-assigned', - old_value=1.0, new_value=2.0) - submit_regression(client, app, [fc_uuid]) - return fc_uuid +def _create_assigned_fieldchange(app): + """Create a field change assigned to a regression via direct DB helpers. - -def _create_ignored_fieldchange(client, app): - """Create an ignored field change.""" - fc_uuid = _create_fieldchange_fixture(client, app, prefix='fc-ign', - old_value=5.0, new_value=10.0) - headers = make_scoped_headers(app, 'triage') - resp = client.post(f'/api/v5/nts/field-changes/{fc_uuid}/ignore', - headers=headers) - assert resp.status_code == 201, f"Ignore failed: {resp.get_json()}" + Uses direct DB helpers because the regressions endpoint is not yet + rewritten. + """ + tag = uuid.uuid4().hex[:8] + db = app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + + machine = create_machine(session, ts, name=f'fc-assigned-m-{tag}') + test = create_test(session, ts, name=f'fc-assigned/test/{tag}') + c1 = create_commit(session, ts, commit=f'fc-assigned-c1-{tag}') + c2 = create_commit(session, ts, commit=f'fc-assigned-c2-{tag}') + + fc = create_fieldchange(session, ts, c1, c2, machine, test, + 'execution_time', old_value=1.0, new_value=2.0) + create_regression(session, ts, field_changes=[fc]) + session.commit() + fc_uuid = fc.uuid + session.close() return fc_uuid @@ -110,20 +114,12 @@ def test_list_contains_unassigned_fc(self): def test_list_excludes_assigned_fc(self): """Field changes with a RegressionIndicator should NOT appear.""" - assigned_uuid = _create_assigned_fieldchange(self.client, self.app) + assigned_uuid = _create_assigned_fieldchange(self.app) resp = self.client.get(PREFIX + '/field-changes') data = resp.get_json() uuids = [fc['uuid'] for fc in data['items']] self.assertNotIn(assigned_uuid, uuids) - def test_list_excludes_ignored_fc(self): - """Field changes with a ChangeIgnore should NOT appear.""" - ignored_uuid = _create_ignored_fieldchange(self.client, self.app) - resp = self.client.get(PREFIX + '/field-changes') - data = resp.get_json() - uuids = [fc['uuid'] for fc in data['items']] - self.assertNotIn(ignored_uuid, uuids) - def test_list_item_has_expected_fields(self): _create_unassigned_fieldchange(self.client, self.app) resp = self.client.get(PREFIX + '/field-changes') @@ -136,9 +132,8 @@ def test_list_item_has_expected_fields(self): self.assertIn('metric', item) self.assertIn('old_value', item) self.assertIn('new_value', item) - self.assertIn('start_order', item) - self.assertIn('end_order', item) - self.assertIn('run_uuid', item) + self.assertIn('start_commit', item) + self.assertIn('end_commit', item) def test_list_filter_by_machine(self): """Filter unassigned field changes by machine name.""" @@ -212,6 +207,24 @@ def test_list_filter_by_metric(self): uuids = [item['uuid'] for item in data['items']] self.assertIn(fc_uuid, uuids) + def test_list_filter_nonexistent_machine_404(self): + """Filtering by a nonexistent machine name returns 404.""" + resp = self.client.get( + PREFIX + '/field-changes?machine=no-such-machine-xyz') + self.assertEqual(resp.status_code, 404) + + def test_list_filter_nonexistent_test_404(self): + """Filtering by a nonexistent test name returns 404.""" + resp = self.client.get( + PREFIX + '/field-changes?test=no/such/test/xyz') + self.assertEqual(resp.status_code, 404) + + def test_list_filter_unknown_metric_400(self): + """Filtering by an unknown metric name returns 400.""" + resp = self.client.get( + PREFIX + '/field-changes?metric=no_such_metric_xyz') + self.assertEqual(resp.status_code, 400) + def test_list_pagination(self): """Test pagination of unassigned field changes.""" for _ in range(3): @@ -234,160 +247,9 @@ def test_invalid_cursor_returns_400(self): # ========================================================================== -# Ignore Tests +# Pagination Tests # ========================================================================== -class TestFieldChangeIgnore(unittest.TestCase): - @classmethod - def setUpClass(cls): - super().setUpClass() - cls.app = create_app(sys.argv[1]) - cls.client = create_client(cls.app) - - def test_ignore_field_change(self): - fc_uuid = _create_unassigned_fieldchange(self.client, self.app) - headers = _triage_headers(self.app) - resp = self.client.post( - PREFIX + f'/field-changes/{fc_uuid}/ignore', - headers=headers, - ) - self.assertEqual(resp.status_code, 201) - data = resp.get_json() - self.assertEqual(data['status'], 'ignored') - self.assertEqual(data['field_change_uuid'], fc_uuid) - - def test_ignore_removes_from_unassigned_list(self): - fc_uuid = _create_unassigned_fieldchange(self.client, self.app) - headers = _triage_headers(self.app) - - # Ignore it - resp = self.client.post( - PREFIX + f'/field-changes/{fc_uuid}/ignore', - headers=headers, - ) - self.assertEqual(resp.status_code, 201) - - # Verify it's no longer in the unassigned list - resp2 = self.client.get(PREFIX + '/field-changes') - data2 = resp2.get_json() - uuids = [fc['uuid'] for fc in data2['items']] - self.assertNotIn(fc_uuid, uuids) - - def test_ignore_already_ignored_409(self): - fc_uuid = _create_unassigned_fieldchange(self.client, self.app) - headers = _triage_headers(self.app) - - # Ignore once - resp = self.client.post( - PREFIX + f'/field-changes/{fc_uuid}/ignore', - headers=headers, - ) - self.assertEqual(resp.status_code, 201) - - # Ignore again -- should be 409 - resp2 = self.client.post( - PREFIX + f'/field-changes/{fc_uuid}/ignore', - headers=headers, - ) - self.assertEqual(resp2.status_code, 409) - - def test_ignore_nonexistent_404(self): - headers = _triage_headers(self.app) - resp = self.client.post( - PREFIX + '/field-changes/nonexistent-uuid/ignore', - headers=headers, - ) - self.assertEqual(resp.status_code, 404) - - def test_ignore_no_auth_401(self): - fc_uuid = _create_unassigned_fieldchange(self.client, self.app) - resp = self.client.post( - PREFIX + f'/field-changes/{fc_uuid}/ignore', - ) - self.assertEqual(resp.status_code, 401) - - def test_ignore_read_scope_403(self): - fc_uuid = _create_unassigned_fieldchange(self.client, self.app) - headers = make_scoped_headers(self.app, 'read') - resp = self.client.post( - PREFIX + f'/field-changes/{fc_uuid}/ignore', - headers=headers, - ) - self.assertEqual(resp.status_code, 403) - - -# ========================================================================== -# Un-ignore Tests -# ========================================================================== - -class TestFieldChangeUnignore(unittest.TestCase): - @classmethod - def setUpClass(cls): - super().setUpClass() - cls.app = create_app(sys.argv[1]) - cls.client = create_client(cls.app) - - def test_unignore_field_change(self): - fc_uuid = _create_ignored_fieldchange(self.client, self.app) - headers = _triage_headers(self.app) - resp = self.client.delete( - PREFIX + f'/field-changes/{fc_uuid}/ignore', - headers=headers, - ) - self.assertEqual(resp.status_code, 204) - - def test_unignore_restores_to_unassigned_list(self): - fc_uuid = _create_ignored_fieldchange(self.client, self.app) - headers = _triage_headers(self.app) - - # Un-ignore it - resp = self.client.delete( - PREFIX + f'/field-changes/{fc_uuid}/ignore', - headers=headers, - ) - self.assertEqual(resp.status_code, 204) - - # Verify it appears in the unassigned list - resp2 = self.client.get(PREFIX + '/field-changes') - data2 = resp2.get_json() - uuids = [fc['uuid'] for fc in data2['items']] - self.assertIn(fc_uuid, uuids) - - def test_unignore_not_ignored_404(self): - """Un-ignoring a field change that's not ignored should return 404.""" - fc_uuid = _create_unassigned_fieldchange(self.client, self.app) - headers = _triage_headers(self.app) - resp = self.client.delete( - PREFIX + f'/field-changes/{fc_uuid}/ignore', - headers=headers, - ) - self.assertEqual(resp.status_code, 404) - - def test_unignore_nonexistent_404(self): - headers = _triage_headers(self.app) - resp = self.client.delete( - PREFIX + '/field-changes/nonexistent-uuid/ignore', - headers=headers, - ) - self.assertEqual(resp.status_code, 404) - - def test_unignore_no_auth_401(self): - fc_uuid = _create_ignored_fieldchange(self.client, self.app) - resp = self.client.delete( - PREFIX + f'/field-changes/{fc_uuid}/ignore', - ) - self.assertEqual(resp.status_code, 401) - - def test_unignore_read_scope_403(self): - fc_uuid = _create_ignored_fieldchange(self.client, self.app) - headers = make_scoped_headers(self.app, 'read') - resp = self.client.delete( - PREFIX + f'/field-changes/{fc_uuid}/ignore', - headers=headers, - ) - self.assertEqual(resp.status_code, 403) - - class TestFieldChangePagination(unittest.TestCase): """Exhaustive cursor pagination tests for GET /api/v5/{ts}/field-changes.""" @classmethod @@ -456,15 +318,14 @@ def setUpClass(cls): cls._machine_name = f'create-fc-m-{uuid.uuid4().hex[:8]}' cls._test_name = f'create-fc/test/{uuid.uuid4().hex[:8]}' - cls._start_rev = f'create-fc-o1-{uuid.uuid4().hex[:8]}' - cls._end_rev = f'create-fc-o2-{uuid.uuid4().hex[:8]}' + cls._start_commit = f'create-fc-c1-{uuid.uuid4().hex[:8]}' + cls._end_commit = f'create-fc-c2-{uuid.uuid4().hex[:8]}' cls._field_name = 'execution_time' - submit_run(cls.client, cls._machine_name, cls._start_rev, + submit_run(cls.client, cls._machine_name, cls._start_commit, [{'name': cls._test_name, 'execution_time': [1.0]}]) - data = submit_run(cls.client, cls._machine_name, cls._end_rev, - [{'name': cls._test_name, 'execution_time': [2.0]}]) - cls._run_uuid = data['run_uuid'] + submit_run(cls.client, cls._machine_name, cls._end_commit, + [{'name': cls._test_name, 'execution_time': [2.0]}]) def _valid_body(self, **overrides): """Return a valid POST body dict with optional overrides.""" @@ -474,8 +335,8 @@ def _valid_body(self, **overrides): 'metric': self._field_name, 'old_value': 10.0, 'new_value': 20.0, - 'start_order': self._start_rev, - 'end_order': self._end_rev, + 'start_commit': self._start_commit, + 'end_commit': self._end_commit, } body.update(overrides) return body @@ -500,36 +361,8 @@ def test_create_field_change_201(self): self.assertEqual(data['metric'], self._field_name) self.assertAlmostEqual(data['old_value'], 10.0) self.assertAlmostEqual(data['new_value'], 20.0) - self.assertEqual(data['start_order'], self._start_rev) - self.assertEqual(data['end_order'], self._end_rev) - - def test_create_with_run_uuid(self): - """POST with optional run_uuid returns 201 with run_uuid in response.""" - headers = _submit_headers(self.app) - headers['Content-Type'] = 'application/json' - body = self._valid_body(run_uuid=self._run_uuid) - resp = self.client.post( - PREFIX + '/field-changes', - data=json.dumps(body), - headers=headers, - ) - self.assertEqual(resp.status_code, 201) - data = resp.get_json() - self.assertEqual(data['run_uuid'], self._run_uuid) - - def test_create_without_run_uuid_returns_null(self): - """POST without run_uuid should return run_uuid as None.""" - headers = _submit_headers(self.app) - headers['Content-Type'] = 'application/json' - body = self._valid_body() - resp = self.client.post( - PREFIX + '/field-changes', - data=json.dumps(body), - headers=headers, - ) - self.assertEqual(resp.status_code, 201) - data = resp.get_json() - self.assertIsNone(data['run_uuid']) + self.assertEqual(data['start_commit'], self._start_commit) + self.assertEqual(data['end_commit'], self._end_commit) def test_each_create_gets_unique_uuid(self): """Two POSTs should produce field changes with different UUIDs.""" @@ -572,7 +405,7 @@ def test_created_fc_appears_in_list(self): # -- Missing required fields -- - def test_missing_machine_name_400(self): + def test_missing_machine_422(self): headers = _submit_headers(self.app) headers['Content-Type'] = 'application/json' body = self._valid_body() @@ -584,7 +417,7 @@ def test_missing_machine_name_400(self): ) self.assertEqual(resp.status_code, 422) - def test_missing_test_name_400(self): + def test_missing_test_422(self): headers = _submit_headers(self.app) headers['Content-Type'] = 'application/json' body = self._valid_body() @@ -596,7 +429,7 @@ def test_missing_test_name_400(self): ) self.assertEqual(resp.status_code, 422) - def test_missing_field_name_400(self): + def test_missing_metric_422(self): headers = _submit_headers(self.app) headers['Content-Type'] = 'application/json' body = self._valid_body() @@ -608,7 +441,7 @@ def test_missing_field_name_400(self): ) self.assertEqual(resp.status_code, 422) - def test_missing_old_value_400(self): + def test_missing_old_value_422(self): headers = _submit_headers(self.app) headers['Content-Type'] = 'application/json' body = self._valid_body() @@ -620,11 +453,11 @@ def test_missing_old_value_400(self): ) self.assertEqual(resp.status_code, 422) - def test_missing_start_order_400(self): + def test_missing_new_value_422(self): headers = _submit_headers(self.app) headers['Content-Type'] = 'application/json' body = self._valid_body() - del body['start_order'] + del body['new_value'] resp = self.client.post( PREFIX + '/field-changes', data=json.dumps(body), @@ -632,11 +465,11 @@ def test_missing_start_order_400(self): ) self.assertEqual(resp.status_code, 422) - def test_missing_new_value_400(self): + def test_missing_start_commit_422(self): headers = _submit_headers(self.app) headers['Content-Type'] = 'application/json' body = self._valid_body() - del body['new_value'] + del body['start_commit'] resp = self.client.post( PREFIX + '/field-changes', data=json.dumps(body), @@ -644,11 +477,11 @@ def test_missing_new_value_400(self): ) self.assertEqual(resp.status_code, 422) - def test_missing_end_order_400(self): + def test_missing_end_commit_422(self): headers = _submit_headers(self.app) headers['Content-Type'] = 'application/json' body = self._valid_body() - del body['end_order'] + del body['end_commit'] resp = self.client.post( PREFIX + '/field-changes', data=json.dumps(body), @@ -680,7 +513,7 @@ def test_nonexistent_test_404(self): ) self.assertEqual(resp.status_code, 404) - def test_unknown_field_name_400(self): + def test_unknown_metric_400(self): headers = _submit_headers(self.app) headers['Content-Type'] = 'application/json' body = self._valid_body(metric='no_such_field_xyz') @@ -691,21 +524,10 @@ def test_unknown_field_name_400(self): ) self.assertEqual(resp.status_code, 400) - def test_nonexistent_start_order_404(self): - headers = _submit_headers(self.app) - headers['Content-Type'] = 'application/json' - body = self._valid_body(start_order='nonexistent-rev-xyz') - resp = self.client.post( - PREFIX + '/field-changes', - data=json.dumps(body), - headers=headers, - ) - self.assertEqual(resp.status_code, 404) - - def test_nonexistent_end_order_404(self): + def test_nonexistent_start_commit_404(self): headers = _submit_headers(self.app) headers['Content-Type'] = 'application/json' - body = self._valid_body(end_order='nonexistent-rev-xyz') + body = self._valid_body(start_commit='nonexistent-commit-xyz') resp = self.client.post( PREFIX + '/field-changes', data=json.dumps(body), @@ -713,10 +535,10 @@ def test_nonexistent_end_order_404(self): ) self.assertEqual(resp.status_code, 404) - def test_nonexistent_run_uuid_404(self): + def test_nonexistent_end_commit_404(self): headers = _submit_headers(self.app) headers['Content-Type'] = 'application/json' - body = self._valid_body(run_uuid='nonexistent-run-uuid-xyz') + body = self._valid_body(end_commit='nonexistent-commit-xyz') resp = self.client.post( PREFIX + '/field-changes', data=json.dumps(body), From 05f27acafc0469ecbb37adcad33b2e12dce40cbc Mon Sep 17 00:00:00 2001 From: Louis Dionne Date: Tue, 14 Apr 2026 00:56:48 -0400 Subject: [PATCH 046/143] [API] Rewrite regressions endpoint for v5 DB MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Delegate to V5TestSuiteDB methods (create_regression, update_regression, delete_regression, add_regression_indicator, remove_regression_indicator) instead of manual ORM construction. All 10 routes preserved with same behavior. Key changes: - Replace resolve_metric() with validate_metric_name() + field_name string filter (no more field_id FK) - Replace manual Regression()/RegressionIndicator() construction with ts.create_regression() and ts.add_regression_indicator() - Add joinedload() for indicator serialization (eliminates N+1 queries on detail/create/update/merge/split responses) - Use IntegrityError catch for duplicate indicator detection instead of manual pre-check query - List filters: lookup_machine/lookup_test → 404 for nonexistent names (consistent with field_changes endpoint) Merge/split remain as endpoint-level logic (no DB methods for these composite operations). Indicator movement uses direct regression_id updates for efficiency. Tests: 72 (was 70 + 2 new filter 404 tests). Updated indicator field assertions (start_order→start_commit, end_order→end_commit, removed run_uuid). All use API-based helpers (preserving 7b8ac8d decoupling). Docs: Added filter 404 behavior to design doc R5. Removed stale ChangeIgnore reference from API implementation plan machines section. Co-Authored-By: Claude Opus 4.6 (1M context) --- docs/design/v5-api.md | 1 + docs/v5-api-implementation-plan.md | 8 +- lnt/server/api/v5/endpoints/regressions.py | 306 +++++++++------------ tests/server/api/v5/test_regressions.py | 21 +- 4 files changed, 155 insertions(+), 181 deletions(-) diff --git a/docs/design/v5-api.md b/docs/design/v5-api.md index ba007db56..868f02903 100644 --- a/docs/design/v5-api.md +++ b/docs/design/v5-api.md @@ -149,6 +149,7 @@ R5: Filtering and Sorting - has_profile=true (for samples) - sort= (prefix with - for descending: sort=-start_time) - Exact filters and available sort fields defined per endpoint in the OpenAPI spec +- Filtering by a nonexistent entity name (machine=, test=) returns 404. Filtering by an unknown metric returns 400. R6: Response Format diff --git a/docs/v5-api-implementation-plan.md b/docs/v5-api-implementation-plan.md index 61452b800..a9b0cbee1 100644 --- a/docs/v5-api-implementation-plan.md +++ b/docs/v5-api-implementation-plan.md @@ -359,12 +359,8 @@ GET /api/v5/{ts}/machines/{machine_name}/runs — List runs (cursor-paginate for race conditions. Consider adding a DB unique constraint via migration. - On PATCH with name change: check new name uniqueness. Response includes new URL in `Location` header. -- On DELETE: chunked deletion (batches of 50-100 runs) to avoid OOM/timeout. - **Important**: `ChangeIgnore` rows have an FK to `FieldChange` but NO cascade configured. - On Postgres, deleting FieldChanges (via machine cascade) will fail with FK violations - unless ChangeIgnore rows are deleted first. This is a pre-existing bug in v4. The v5 - delete code must explicitly delete ChangeIgnore rows for the machine's FieldChanges - before the cascade delete runs. +- On DELETE: cascades to runs (and their samples), field changes, and + regression indicators via FK cascade. No ChangeIgnore in v5. - Auth: read=GET, manage=POST/PATCH/DELETE. **Filters** (on list): `name_contains=`, `name_prefix=` diff --git a/lnt/server/api/v5/endpoints/regressions.py b/lnt/server/api/v5/endpoints/regressions.py index ca28931f9..7b0a67daa 100644 --- a/lnt/server/api/v5/endpoints/regressions.py +++ b/lnt/server/api/v5/endpoints/regressions.py @@ -12,19 +12,21 @@ DELETE /api/v5/{ts}/regressions/{uuid}/indicators/{fc_uuid} -- Remove indicator """ -import uuid as uuid_module - from flask import g, jsonify, make_response from flask.views import MethodView from flask_smorest import Blueprint +from sqlalchemy.exc import IntegrityError +from sqlalchemy.orm import joinedload from ..auth import require_scope from ..errors import abort_with_error, reject_unknown_params from ..helpers import ( lookup_fieldchange, + lookup_machine, lookup_regression, - resolve_metric, + lookup_test, serialize_fieldchange, + validate_metric_name, ) from ..etag import add_etag_to_response from ..pagination import ( @@ -60,12 +62,34 @@ # Helpers # --------------------------------------------------------------------------- -def _serialize_indicator(ri, ts): +def _fc_load_branches(base, ts): + """Append FieldChange relationship loads to a joinedload base.""" + return [ + base.joinedload(ts.FieldChange.test), + base.joinedload(ts.FieldChange.machine), + base.joinedload(ts.FieldChange.start_commit), + base.joinedload(ts.FieldChange.end_commit), + ] + + +def _indicator_load_options(ts): + """Return joinedload options for eager-loading indicator relationships.""" + base = joinedload(ts.Regression.indicators) \ + .joinedload(ts.RegressionIndicator.field_change) + return _fc_load_branches(base, ts) + + +def _indicator_query_options(ts): + """Return joinedload options for a RegressionIndicator query.""" + base = joinedload(ts.RegressionIndicator.field_change) + return _fc_load_branches(base, ts) + + +def _serialize_indicator(ri): """Serialize a RegressionIndicator into the API response dict.""" fc = ri.field_change if fc is None: return None - result = serialize_fieldchange(fc) result['field_change_uuid'] = fc.uuid return result @@ -81,15 +105,14 @@ def _serialize_regression_list(regression): } -def _serialize_regression_detail(regression, session, ts): - """Serialize a Regression for the detail endpoint (with indicators).""" - indicators = session.query(ts.RegressionIndicator).filter( - ts.RegressionIndicator.regression_id == regression.id - ).all() +def _serialize_regression_detail(regression): + """Serialize a Regression for the detail endpoint (with indicators). + Requires indicators to be eager-loaded via _indicator_load_options(). + """ serialized_indicators = [] - for ri in indicators: - ind = _serialize_indicator(ri, ts) + for ri in regression.indicators: + ind = _serialize_indicator(ri) if ind is not None: serialized_indicators.append(ind) @@ -102,6 +125,34 @@ def _serialize_regression_detail(regression, session, ts): } +def _validate_state(state_str): + """Validate and convert a state string to its DB integer. + + Aborts with 400 if invalid. + """ + db_state = state_to_db(state_str) + if db_state is None: + abort_with_error( + 400, + "Invalid state '%s'. Valid states: %s" + % (state_str, ', '.join(sorted(STATE_TO_DB.keys())))) + return db_state + + +def _lookup_regression_with_indicators(session, ts, regression_uuid): + """Look up a regression by UUID with eager-loaded indicators. + + Aborts with 404 if not found. + """ + reg = session.query(ts.Regression) \ + .options(*_indicator_load_options(ts)) \ + .filter(ts.Regression.uuid == regression_uuid) \ + .first() + if reg is None: + abort_with_error(404, "Regression '%s' not found" % regression_uuid) + return reg + + # --------------------------------------------------------------------------- # Regression List / Create # --------------------------------------------------------------------------- @@ -122,32 +173,26 @@ def get(self, query_args, testsuite): query = session.query(ts.Regression) - # Filter by state (supports comma-separated values) state_values = query_args['state'] if state_values: - db_states = [] - for sv in state_values: - db_val = state_to_db(sv) - if db_val is None: - abort_with_error( - 400, - "Invalid state '%s'. Valid states: %s" - % (sv, ', '.join(sorted(STATE_TO_DB.keys())))) - db_states.append(db_val) + db_states = [_validate_state(sv) for sv in state_values] query = query.filter(ts.Regression.state.in_(db_states)) - # Filter by machine, test, and/or metric name. All three need - # the same base JOINs through indicators -> field changes. machine_name = query_args.get('machine') test_name = query_args.get('test') field_name = query_args.get('metric') - # Resolve metric name to field ID (no DB query needed) - matching_field = None + # Validate entity names before building JOINs (404/400 on bad names) + machine = None + if machine_name: + machine = lookup_machine(session, ts, machine_name) + test = None + if test_name: + test = lookup_test(session, ts, test_name) if field_name: - matching_field = resolve_metric(ts, field_name) + validate_metric_name(ts, field_name) - if machine_name or test_name or field_name: + if machine or test or field_name: query = query.join( ts.RegressionIndicator, ts.RegressionIndicator.regression_id == ts.Regression.id @@ -156,23 +201,19 @@ def get(self, query_args, testsuite): ts.RegressionIndicator.field_change_id == ts.FieldChange.id ) - if machine_name: - query = query.join( - ts.Machine, - ts.FieldChange.machine_id == ts.Machine.id - ).filter(ts.Machine.name == machine_name) + if machine: + query = query.filter( + ts.FieldChange.machine_id == machine.id) - if test_name: - query = query.join( - ts.Test, - ts.FieldChange.test_id == ts.Test.id - ).filter(ts.Test.name == test_name) + if test: + query = query.filter( + ts.FieldChange.test_id == test.id) if field_name: query = query.filter( - ts.FieldChange.field_id == matching_field.id) + ts.FieldChange.field_name == field_name) - if machine_name or test_name or field_name: + if machine or test or field_name: query = query.distinct() cursor_str = query_args.get('cursor') @@ -192,39 +233,24 @@ def post(self, body, testsuite): session = g.db_session fc_uuids = body['field_change_uuids'] + field_changes = [lookup_fieldchange(session, ts, u) for u in fc_uuids] - # Look up all field changes by UUID - field_changes = [] - for fc_uuid in fc_uuids: - fc = lookup_fieldchange(session, ts, fc_uuid) - field_changes.append(fc) - - # Determine state state_str = body.get('state') or 'detected' - db_state = state_to_db(state_str) - if db_state is None: - abort_with_error( - 400, - "Invalid state '%s'. Valid states: %s" - % (state_str, ', '.join(sorted(STATE_TO_DB.keys())))) + db_state = _validate_state(state_str) - # Create regression title = body.get('title') or 'Regression of %d benchmarks' % len( field_changes) bug = body.get('bug') or '' - regression = ts.Regression(title, bug, db_state) - regression.uuid = str(uuid_module.uuid4()) - session.add(regression) - session.flush() + regression = ts.create_regression( + session, title, [fc.id for fc in field_changes], + bug=bug, state=db_state) - # Add indicators - for fc in field_changes: - ri = ts.RegressionIndicator(regression, fc) - session.add(ri) - session.flush() + # Reload with eager-loaded indicators for serialization + regression = _lookup_regression_with_indicators( + session, ts, regression.uuid) - result = _serialize_regression_detail(regression, session, ts) + result = _serialize_regression_detail(regression) resp = jsonify(result) resp.status_code = 201 return resp @@ -245,47 +271,31 @@ def get(self, testsuite, regression_uuid): reject_unknown_params(set()) ts = g.ts session = g.db_session - regression = lookup_regression(session, ts, regression_uuid) - data = _serialize_regression_detail(regression, session, ts) + regression = _lookup_regression_with_indicators( + session, ts, regression_uuid) + data = _serialize_regression_detail(regression) return add_etag_to_response(jsonify(data), data) @require_scope('triage') @blp.arguments(RegressionUpdateSchema) @blp.response(200, RegressionDetailSchema) def patch(self, body, testsuite, regression_uuid): - """Update regression title, bug URL, and/or state. - - Request body (all fields optional): - { - "title": "new title", - "bug": "new bug URL", - "state": "active" - } - """ + """Update regression title, bug URL, and/or state.""" ts = g.ts session = g.db_session - regression = lookup_regression(session, ts, regression_uuid) - - if 'title' in body: - regression.title = body['title'] - - if 'bug' in body: - regression.bug = body['bug'] + regression = _lookup_regression_with_indicators( + session, ts, regression_uuid) + title = body.get('title') + bug = body.get('bug') + state = None if 'state' in body: - db_state = state_to_db(body['state']) - if db_state is None: - abort_with_error( - 400, - "Invalid state '%s'. Valid states: %s" - % (body['state'], - ', '.join(sorted(STATE_TO_DB.keys())))) - regression.state = db_state + state = _validate_state(body['state']) - session.flush() + ts.update_regression( + session, regression, title=title, bug=bug, state=state) - return jsonify( - _serialize_regression_detail(regression, session, ts)) + return jsonify(_serialize_regression_detail(regression)) @require_scope('triage') @blp.response(204) @@ -294,15 +304,7 @@ def delete(self, testsuite, regression_uuid): ts = g.ts session = g.db_session regression = lookup_regression(session, ts, regression_uuid) - - # Delete indicators first - session.query(ts.RegressionIndicator).filter( - ts.RegressionIndicator.regression_id == regression.id - ).delete(synchronize_session='fetch') - - session.delete(regression) - session.flush() - + ts.delete_regression(session, regression.id) return make_response('', 204) @@ -330,14 +332,12 @@ def post(self, body, testsuite, regression_uuid): source_uuids = body['source_regression_uuids'] - # Validate: cannot merge into self for suuid in source_uuids: if suuid == regression_uuid: abort_with_error( 400, "Cannot merge a regression into itself") - # Collect existing indicator field_change_ids for the target - # (for deduplication) + # Collect existing indicator field_change_ids for deduplication existing_fc_ids = set() target_indicators = session.query(ts.RegressionIndicator).filter( ts.RegressionIndicator.regression_id == target.id @@ -345,14 +345,9 @@ def post(self, body, testsuite, regression_uuid): for ri in target_indicators: existing_fc_ids.add(ri.field_change_id) - # Process each source regression - sources = [] - for suuid in source_uuids: - source = lookup_regression(session, ts, suuid) - sources.append(source) + sources = [lookup_regression(session, ts, u) for u in source_uuids] for source in sources: - # Move indicators from source to target (with dedup) source_indicators = session.query(ts.RegressionIndicator).filter( ts.RegressionIndicator.regression_id == source.id ).all() @@ -360,19 +355,19 @@ def post(self, body, testsuite, regression_uuid): for ri in source_indicators: if ri.field_change_id not in existing_fc_ids: ri.regression_id = target.id - ri.regression = target existing_fc_ids.add(ri.field_change_id) else: - # Duplicate -- remove it session.delete(ri) - # Mark source as IGNORED - source.state = STATE_TO_DB['ignored'] + ts.update_regression( + session, source, state=STATE_TO_DB['ignored']) session.flush() - return jsonify( - _serialize_regression_detail(target, session, ts)) + # Reload with eager-loaded indicators for serialization + target = _lookup_regression_with_indicators( + session, ts, regression_uuid) + return jsonify(_serialize_regression_detail(target)) # --------------------------------------------------------------------------- @@ -397,17 +392,12 @@ def post(self, body, testsuite, regression_uuid): fc_uuids = body['field_change_uuids'] - # Get all current indicators for the source regression all_indicators = session.query(ts.RegressionIndicator).filter( ts.RegressionIndicator.regression_id == source.id ).all() - # Build a map from field_change_id to indicator - fc_id_to_ri = {} - for ri in all_indicators: - fc_id_to_ri[ri.field_change_id] = ri + fc_id_to_ri = {ri.field_change_id: ri for ri in all_indicators} - # Resolve the field change UUIDs to indicators indicators_to_move = [] for fc_uuid in fc_uuids: fc = lookup_fieldchange(session, ts, fc_uuid) @@ -419,29 +409,27 @@ def post(self, body, testsuite, regression_uuid): "'%s'" % (fc_uuid, regression_uuid)) indicators_to_move.append(ri) - # Validate: cannot split ALL indicators if len(indicators_to_move) >= len(all_indicators): abort_with_error( 400, "Cannot split all indicators from a regression. " "At least one indicator must remain.") - # Create new regression - new_regression = ts.Regression( - source.title, source.bug or '', source.state) - new_regression.uuid = str(uuid_module.uuid4()) - session.add(new_regression) - session.flush() + # Create new regression (empty indicators, then move them) + new_regression = ts.create_regression( + session, source.title, [], bug=source.bug or '', + state=source.state) - # Move indicators to the new regression for ri in indicators_to_move: ri.regression_id = new_regression.id - ri.regression = new_regression session.flush() + # Reload with eager-loaded indicators for serialization + new_regression = _lookup_regression_with_indicators( + session, ts, new_regression.uuid) return jsonify( - _serialize_regression_detail(new_regression, session, ts)), 201 + _serialize_regression_detail(new_regression)), 201 # --------------------------------------------------------------------------- @@ -462,9 +450,10 @@ def get(self, query_args, testsuite, regression_uuid): session = g.db_session regression = lookup_regression(session, ts, regression_uuid) - query = session.query(ts.RegressionIndicator).filter( - ts.RegressionIndicator.regression_id == regression.id - ) + query = session.query(ts.RegressionIndicator) \ + .options(*_indicator_query_options(ts)) \ + .filter( + ts.RegressionIndicator.regression_id == regression.id) cursor_str = query_args.get('cursor') limit = query_args['limit'] @@ -473,7 +462,7 @@ def get(self, query_args, testsuite, regression_uuid): serialized = [] for ri in items: - ind = _serialize_indicator(ri, ts) + ind = _serialize_indicator(ri) if ind is not None: serialized.append(ind) @@ -483,11 +472,7 @@ def get(self, query_args, testsuite, regression_uuid): @blp.arguments(IndicatorAddSchema) @blp.response(201, IndicatorResponseSchema) def post(self, body, testsuite, regression_uuid): - """Add a field change as an indicator to this regression. - - Request body: - {"field_change_uuid": "..."} - """ + """Add a field change as an indicator to this regression.""" ts = g.ts session = g.db_session regression = lookup_regression(session, ts, regression_uuid) @@ -495,22 +480,16 @@ def post(self, body, testsuite, regression_uuid): fc_uuid = body['field_change_uuid'] fc = lookup_fieldchange(session, ts, fc_uuid) - # Check for duplicate - existing = session.query(ts.RegressionIndicator).filter( - ts.RegressionIndicator.regression_id == regression.id, - ts.RegressionIndicator.field_change_id == fc.id, - ).first() - if existing: + try: + ri = ts.add_regression_indicator(session, regression, fc) + except IntegrityError: + session.rollback() abort_with_error( 409, "Field change '%s' is already an indicator of this " "regression" % fc_uuid) - ri = ts.RegressionIndicator(regression, fc) - session.add(ri) - session.flush() - - result = _serialize_indicator(ri, ts) + result = _serialize_indicator(ri) resp = jsonify(result) resp.status_code = 201 return resp @@ -528,27 +507,14 @@ def delete(self, testsuite, regression_uuid, fc_uuid): ts = g.ts session = g.db_session regression = lookup_regression(session, ts, regression_uuid) + fc = lookup_fieldchange(session, ts, fc_uuid) - # Find the field change by UUID - fc = session.query(ts.FieldChange).filter( - ts.FieldChange.uuid == fc_uuid - ).first() - if fc is None: - abort_with_error( - 404, "Field change '%s' not found" % fc_uuid) - - # Find the indicator linking this field change to this regression - ri = session.query(ts.RegressionIndicator).filter( - ts.RegressionIndicator.regression_id == regression.id, - ts.RegressionIndicator.field_change_id == fc.id, - ).first() - if ri is None: + removed = ts.remove_regression_indicator( + session, regression.id, fc.id) + if not removed: abort_with_error( 404, "Field change '%s' is not an indicator of regression " "'%s'" % (fc_uuid, regression_uuid)) - session.delete(ri) - session.flush() - return make_response('', 204) diff --git a/tests/server/api/v5/test_regressions.py b/tests/server/api/v5/test_regressions.py index 7f02456d5..6894535de 100644 --- a/tests/server/api/v5/test_regressions.py +++ b/tests/server/api/v5/test_regressions.py @@ -2,7 +2,7 @@ # # RUN: rm -rf %t.instance %t.pg.log # RUN: %{utils}/with_postgres.sh %t.pg.log \ -# RUN: %{utils}/with_temporary_instance.py %t.instance \ +# RUN: %{utils}/with_temporary_instance.py --db-version 5.0 %t.instance \ # RUN: -- python %s %t.instance # END. @@ -273,6 +273,18 @@ def test_list_filter_by_metric_unknown_returns_400(self): PREFIX + '/regressions?metric=nonexistent_metric') self.assertEqual(resp.status_code, 400) + def test_list_filter_nonexistent_machine_404(self): + """Filtering by a nonexistent machine name returns 404.""" + resp = self.client.get( + PREFIX + '/regressions?machine=no-such-machine-xyz') + self.assertEqual(resp.status_code, 404) + + def test_list_filter_nonexistent_test_404(self): + """Filtering by a nonexistent test name returns 404.""" + resp = self.client.get( + PREFIX + '/regressions?test=no/such/test/xyz') + self.assertEqual(resp.status_code, 404) + def test_list_filter_combined(self): """Combined machine + test + metric filter narrows results.""" tag = uuid.uuid4().hex[:8] @@ -450,9 +462,8 @@ def test_get_detail(self): self.assertIn('metric', ind) self.assertIn('old_value', ind) self.assertIn('new_value', ind) - self.assertIn('start_order', ind) - self.assertIn('end_order', ind) - self.assertIn('run_uuid', ind) + self.assertIn('start_commit', ind) + self.assertIn('end_commit', ind) def test_detail_nonexistent_404(self): resp = self.client.get( @@ -464,7 +475,7 @@ def test_detail_state_is_string(self): resp = self.client.get(PREFIX + f'/regressions/{reg_uuid}') data = resp.get_json() self.assertIsInstance(data['state'], str) - self.assertEqual(data['state'], 'active') # state=10 -> 'active' + self.assertEqual(data['state'], 'active') class TestRegressionDetailETag(unittest.TestCase): From 0acd9839a0bed011005150c5f6acf5ef4aab6158 Mon Sep 17 00:00:00 2001 From: Louis Dionne Date: Tue, 14 Apr 2026 07:33:38 -0400 Subject: [PATCH 047/143] [API] Rewrite query endpoint for v5 DB MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Replace v4 ORM patterns (Order, SampleField, status_field) with v5 DB models (Commit, direct column access). This is the last endpoint to rewrite — all 10 v5 API endpoints now use the v5 DB layer. Key changes: - order → commit: order/after_order/before_order → commit/after_commit/ before_commit in request params; order dict → commit string + ordinal in response - Sort fields: order → commit (by Commit.ordinal), timestamp → submitted_at (by Run.submitted_at) - Metric resolution: resolve_metric() → validate_metric_name() + getattr(ts.Sample, metric_name) - Remove status_field filtering (v5 has no status_field concept) - NULL ordinal handling: commits without ordinals are excluded when sorting by commit, consistent with query_time_series() - Range filters (after_commit/before_commit) use Commit.ordinal; return 400 if the target commit has no ordinal - Column selection: query selects only needed columns instead of full model instances (better for large result sets up to limit=10000) - run_uuid preserved in response (frontend uses it for multi-sample grouping in graph.ts) Custom cursor pagination preserved (encode/decode/filter algorithms unchanged, only field names updated). Tests: All 91 tests kept and updated. Data setup uses submit_run() + set_ordinal() API helper for ordinal assignment (per D11). Direct DB access only for submitted_at (no API for mutation). Random ordinal bases prevent cross-class unique constraint collisions. Docs: Updated design doc and API implementation plan — commit-based filtering, new sort fields, response format. Co-Authored-By: Claude Opus 4.6 (1M context) --- docs/design/v5-api.md | 7 +- docs/v5-api-implementation-plan.md | 25 +- lnt/server/api/v5/endpoints/query.py | 286 ++++++++----------- lnt/server/api/v5/schemas/query.py | 31 ++- tests/server/api/v5/test_query.py | 364 +++++++++++++++---------- tests/server/api/v5/v5_test_helpers.py | 11 + 6 files changed, 386 insertions(+), 338 deletions(-) diff --git a/docs/design/v5-api.md b/docs/design/v5-api.md index 868f02903..95ea0f6cd 100644 --- a/docs/design/v5-api.md +++ b/docs/design/v5-api.md @@ -105,12 +105,13 @@ Creating a field change requires: machine (name), test (name), metric (name), ol Time Series POST /query - Body (JSON): {metric, machine, test, order, after_order, before_order, + Body (JSON): {metric, machine, test, commit, after_commit, before_commit, after_time, before_time, sort, limit, cursor} The metric field is required; all other fields are optional. The test field accepts a list of names for disjunction queries. -The order field filters for an exact order match and cannot be combined with after_order/before_order. -Returns cursor-paginated time-series data for graphing. Uses field names (not indices) to be self-documenting. +The commit field filters for an exact commit match and cannot be combined with after_commit/before_commit. +Returns cursor-paginated time-series data for graphing. Each data point contains: test, machine, metric, value, commit, ordinal, run_uuid, submitted_at. +Sort fields: test, commit (by ordinal), submitted_at. Default sort: commit,test. Trends (Aggregated) diff --git a/docs/v5-api-implementation-plan.md b/docs/v5-api-implementation-plan.md index a9b0cbee1..5bba31c09 100644 --- a/docs/v5-api-implementation-plan.md +++ b/docs/v5-api-implementation-plan.md @@ -563,7 +563,7 @@ POST /api/v5/{ts}/field-changes — Create a field change **Endpoint:** ``` POST /api/v5/{ts}/query -Body (JSON): {metric, machine, test, order, after_order, before_order, +Body (JSON): {metric, machine, test, commit, after_commit, before_commit, after_time, before_time, sort, limit, cursor} ``` @@ -573,17 +573,18 @@ Body (JSON): {metric, machine, test, order, after_order, before_order, - `metric` is REQUIRED (by name, not ID). All other fields are optional. - `test` is a list of test names for disjunction queries. Unknown test names are silently skipped (no 404). -- Field name → Sample column resolution via `ts.sample_fields` name→column mapping -- Core query: `SELECT field.column, order.*, run.* FROM Sample JOIN Run JOIN Order - WHERE machine_id=X AND test_id IN (...) AND field IS NOT NULL` -- Filter out failing tests if the field has a status_field -- Order filtering: `order` for exact match (=), `after_order`/`before_order` for - exclusive range (>/< on Order.id). `order` cannot be combined with range params. -- Ordering: fetch with SQL ORDER BY on Order.id, then post-sort in Python using - `convert_revision()` for correctness. Apply `after`/`before` filters in Python. - Cap SQL query at 10,000 rows as safety limit. -- Cursor: encode the last order's field values. On next request, use to resume. -- Response per data point: `{test, machine, metric, value, commit, ordinal, submitted_at}` +- Metric → Sample column resolution via `getattr(ts.Sample, metric_name)` +- Core query: `SELECT metric_col, commit.*, run.uuid, run.submitted_at + FROM Sample JOIN Run JOIN Commit WHERE machine_id=X AND test_id IN (...) + AND metric IS NOT NULL` +- Commit filtering: `commit` for exact match (by commit_id), + `after_commit`/`before_commit` for ordinal range (>/< on Commit.ordinal). + `commit` cannot be combined with range params. Commits with NULL ordinal + are excluded when sorting by commit. +- Sort fields: `test` (Test.name), `commit` (Commit.ordinal), + `submitted_at` (Run.submitted_at). Default: `commit,test`. +- Cursor: encode the last row's sort-field values. On next request, resume. +- Response per data point: `{test, machine, metric, value, commit, ordinal, run_uuid, submitted_at}` - Auth: read only. ### 5.11 Schema and Fields diff --git a/lnt/server/api/v5/endpoints/query.py b/lnt/server/api/v5/endpoints/query.py index c8deb7102..cce428f9c 100644 --- a/lnt/server/api/v5/endpoints/query.py +++ b/lnt/server/api/v5/endpoints/query.py @@ -1,7 +1,7 @@ """Query endpoint for the v5 API. POST /api/v5/{ts}/query - Body (JSON): {metric, machine, test, order, after_order, before_order, + Body (JSON): {metric, machine, test, commit, after_commit, before_commit, after_time, before_time, sort, limit, cursor} Returns cursor-paginated data points. The metric field is required; @@ -10,17 +10,21 @@ """ import base64 +import json from flask import g, jsonify from flask.views import MethodView from flask_smorest import Blueprint from sqlalchemy import and_, or_ -from lnt.testing import PASS - from ..auth import require_scope from ..errors import abort_with_error -from ..helpers import parse_datetime, resolve_metric, serialize_order +from ..helpers import ( + lookup_commit, + lookup_machine, + parse_datetime, + validate_metric_name, +) from ..pagination import make_paginated_response from ..schemas.query import QueryEndpointQuerySchema, QueryResponseSchema @@ -31,27 +35,23 @@ description='Query time-series performance data across machines, tests, and metrics', ) -# Default and maximum page sizes. _DEFAULT_LIMIT = 100 _MAX_LIMIT = 10000 -# Allowed sort field names and the columns they map to. -# The actual column references are resolved at query time since the -# model classes are dynamic per test suite. -_ALLOWED_SORT_FIELDS = {'test', 'order', 'timestamp'} +_ALLOWED_SORT_FIELDS = {'test', 'commit', 'submitted_at'} def _parse_sort(sort_str): """Parse a comma-separated sort string into (field_name, ascending) pairs. Examples: - "test,order" -> [("test", True), ("order", True)] - "-timestamp,test" -> [("timestamp", False), ("test", True)] + "test,commit" -> [("test", True), ("commit", True)] + "-submitted_at,test" -> [("submitted_at", False), ("test", True)] Returns a list of (field_name, ascending) tuples, or None on error. """ if not sort_str: - return [('order', True), ('test', True)] + return [('commit', True), ('test', True)] result = [] seen = set() @@ -76,7 +76,7 @@ def _parse_sort(sort_str): return None # Append tiebreakers for deterministic ordering. - for tiebreaker in ('order', 'test'): + for tiebreaker in ('commit', 'test'): if tiebreaker not in seen: result.append((tiebreaker, True)) seen.add(tiebreaker) @@ -88,10 +88,10 @@ def _resolve_sort_column(ts, field_name): """Map a sort field name to its SQLAlchemy column.""" if field_name == 'test': return ts.Test.name - elif field_name == 'order': - return ts.Order.id - elif field_name == 'timestamp': - return ts.Run.start_time + elif field_name == 'commit': + return ts.Commit.ordinal + elif field_name == 'submitted_at': + return ts.Run.submitted_at raise ValueError("Unknown sort field: %s" % field_name) @@ -101,7 +101,6 @@ def _encode_cursor(values): Values are JSON-encoded then base64-wrapped to safely handle values containing any characters (colons, unicode, etc.). """ - import json payload = json.dumps(values, separators=(',', ':')) return base64.urlsafe_b64encode(payload.encode('utf-8')).decode('ascii') @@ -111,7 +110,6 @@ def _decode_cursor(cursor_str, num_fields): Returns None if the cursor is malformed. """ - import json if not cursor_str: return None try: @@ -169,108 +167,57 @@ def _coerce_cursor_value(field_name, value): in most cases. This handles edge cases and type enforcement. Raises ValueError if the value cannot be coerced. """ - if field_name == 'order': + if field_name == 'commit': return int(value) elif field_name == 'test': return str(value) if value is not None else '' - elif field_name == 'timestamp': + elif field_name == 'submitted_at': return value # None or string, both valid return value -def _extract_cursor_values(sort_spec, ts, row_data): +def _extract_cursor_values(sort_spec, row_data): """Extract cursor values from a result row for encoding. - row_data is a dict with keys: test_name, order_id, timestamp. + row_data is a dict with keys: test_name, ordinal, submitted_at. """ values = [] for field_name, _ in sort_spec: if field_name == 'test': values.append(row_data['test_name']) - elif field_name == 'order': - values.append(row_data['order_id']) - elif field_name == 'timestamp': - values.append(row_data['timestamp']) + elif field_name == 'commit': + values.append(row_data['ordinal']) + elif field_name == 'submitted_at': + values.append(row_data['submitted_at']) return values -def _resolve_machine(session, ts, machine_name): - """Resolve a machine name to its model instance. - - Returns (machine, None, None) on success, or - (None, error_message, http_status) on failure. - """ - machines = session.query(ts.Machine).filter( - ts.Machine.name == machine_name - ).all() - if len(machines) == 0: - return None, "Machine '%s' not found" % machine_name, 404 - if len(machines) > 1: - ids = ', '.join(str(m.id) for m in machines) - return None, ( - "Multiple machines named '%s' exist (IDs: %s). " - "Use the v4 UI to merge or rename them." - % (machine_name, ids)), 409 - return machines[0], None, None - - -def _resolve_test(session, ts, test_name): - """Resolve a test name to its model instance.""" - test = session.query(ts.Test).filter( - ts.Test.name == test_name - ).first() - if test is None: - return None, "Test '%s' not found" % test_name - return test, None - - -def _resolve_order(session, ts, order_value): - """Resolve an order field value to its model instance. - - Matches against the first (primary) order field. - """ - if not ts.order_fields: - return None, "Test suite has no order fields" - primary_field = ts.order_fields[0] - order = session.query(ts.Order).filter( - primary_field.column == order_value - ).first() - if order is None: - return None, "Order '%s' not found" % order_value - return order, None - - -def _query_for_field(session, ts, sample_field, machine, test_ids, - sort_spec, cursor_values, order, after_order, - before_order, after_time, before_time, limit): - """Build and execute a query for a single sample field. - - *test_ids* is a list of test IDs to filter by, or None for no filter. +def _build_query(session, ts, metric_col, metric_name, machine, test_ids, + sort_spec, cursor_values, commit, after_commit, + before_commit, after_time, before_time, limit): + """Build and execute the time-series query. Returns a list of dicts ready for serialization, plus a boolean indicating whether there are more results. """ - q = session.query( - sample_field.column, - ts.Order, - ts.Run, - ts.Test, - ts.Machine, - ).select_from(ts.Sample) \ - .join(ts.Run) \ - .join(ts.Order) \ - .join(ts.Test) \ - .join(ts.Machine, ts.Run.machine_id == ts.Machine.id) \ - .filter(sample_field.column.isnot(None)) - - # Filter out failing tests if the field has a status_field. - if sample_field.status_field: - q = q.filter( - (sample_field.status_field.column == PASS) | - (sample_field.status_field.column.is_(None)) + q = ( + session.query( + metric_col.label('metric_value'), + ts.Commit.commit, + ts.Commit.ordinal, + ts.Run.uuid, + ts.Run.submitted_at, + ts.Test.name.label('test_name'), + ts.Machine.name.label('machine_name'), ) + .select_from(ts.Sample) + .join(ts.Run, ts.Sample.run_id == ts.Run.id) + .join(ts.Commit, ts.Run.commit_id == ts.Commit.id) + .join(ts.Test, ts.Sample.test_id == ts.Test.id) + .join(ts.Machine, ts.Run.machine_id == ts.Machine.id) + .filter(metric_col.isnot(None)) + ) - # Apply optional filters. if machine is not None: q = q.filter(ts.Run.machine_id == machine.id) if test_ids is not None: @@ -279,30 +226,35 @@ def _query_for_field(session, ts, sample_field, machine, test_ids, else: q = q.filter(ts.Sample.test_id.in_(test_ids)) - # Apply exact order filter. - if order is not None: - q = q.filter(ts.Order.id == order.id) + # Exact commit filter — by commit identity, not ordinal. + if commit is not None: + q = q.filter(ts.Run.commit_id == commit.id) - # Apply order range filters. - if after_order is not None: - q = q.filter(ts.Order.id > after_order.id) - if before_order is not None: - q = q.filter(ts.Order.id < before_order.id) + # Commit range filters — by ordinal. + if after_commit is not None: + q = q.filter(ts.Commit.ordinal > after_commit.ordinal) + if before_commit is not None: + q = q.filter(ts.Commit.ordinal < before_commit.ordinal) - # Apply timestamp range filters. + # When sorting by commit (ordinal), exclude NULL ordinals. + sort_fields = {fn for fn, _ in sort_spec} + if 'commit' in sort_fields: + q = q.filter(ts.Commit.ordinal.isnot(None)) + + # Time range filters. if after_time is not None: - q = q.filter(ts.Run.start_time > after_time) + q = q.filter(ts.Run.submitted_at > after_time) if before_time is not None: - q = q.filter(ts.Run.start_time < before_time) + q = q.filter(ts.Run.submitted_at < before_time) - # Apply cursor filter. + # Cursor filter. if cursor_values is not None: try: q = q.filter(_build_cursor_filter(ts, sort_spec, cursor_values)) except (ValueError, TypeError): abort_with_error(400, "Invalid pagination cursor") - # Apply ordering. + # Ordering. for field_name, ascending in sort_spec: col = _resolve_sort_column(ts, field_name) q = q.order_by(col.asc() if ascending else col.desc()) @@ -314,22 +266,20 @@ def _query_for_field(session, ts, sample_field, machine, test_ids, rows = rows[:limit] items = [] - for value, order, run, test_obj, machine_obj in rows: - order_dict = serialize_order(order) - - timestamp = None - if run.start_time: - timestamp = run.start_time.isoformat() + for row in rows: + submitted_at = None + if row.submitted_at: + submitted_at = row.submitted_at.isoformat() items.append({ - 'test': test_obj.name, - 'machine': machine_obj.name, - 'metric': sample_field.name, - 'value': value, - 'order': order_dict, - 'run_uuid': run.uuid, - 'timestamp': timestamp, - '_order_id': order.id, + 'test': row.test_name, + 'machine': row.machine_name, + 'metric': metric_name, + 'value': row.metric_value, + 'commit': row.commit, + 'ordinal': row.ordinal, + 'run_uuid': row.uuid, + 'submitted_at': submitted_at, }) return items, has_next @@ -359,28 +309,24 @@ def post(self, query_args, testsuite): test_names = query_args.get('test') field_name = query_args['metric'] - # Resolve entities when provided. machine = None if machine_name: - machine, err, status = _resolve_machine(session, ts, machine_name) - if err: - abort_with_error(status, err) + machine = lookup_machine(session, ts, machine_name) + # Silently skip unknown test names — return no data for them + # rather than 404-ing the entire request. test_ids = None if test_names: test_ids = [] for tn in test_names: - test, err = _resolve_test(session, ts, tn) - if err: - # Silently skip unknown test names — return no data - # for them rather than 404-ing the entire request. - continue - test_ids.append(test.id) + test = ts.get_test(session, name=tn) + if test is not None: + test_ids.append(test.id) if not test_ids: - # All requested tests are unknown — return empty response. return jsonify(make_paginated_response([], None)) - field = resolve_metric(ts, field_name) + validate_metric_name(ts, field_name) + metric_col = getattr(ts.Sample, field_name) # ------------------------------------------------------------------ # Parse sort parameter @@ -396,35 +342,37 @@ def post(self, query_args, testsuite): # ------------------------------------------------------------------ # Parse range filters # ------------------------------------------------------------------ - order_str = query_args.get('order') - after_order_str = query_args.get('after_order') - before_order_str = query_args.get('before_order') + commit_str = query_args.get('commit') + after_commit_str = query_args.get('after_commit') + before_commit_str = query_args.get('before_commit') after_time_str = query_args.get('after_time') before_time_str = query_args.get('before_time') - if order_str and (after_order_str or before_order_str): + if commit_str and (after_commit_str or before_commit_str): abort_with_error( 400, - "The 'order' parameter cannot be combined with " - "'after_order' or 'before_order'") - - order = None - if order_str: - order, err = _resolve_order(session, ts, order_str) - if err: - abort_with_error(404, err) - - after_order = None - if after_order_str: - after_order, err = _resolve_order(session, ts, after_order_str) - if err: - abort_with_error(404, err) - - before_order = None - if before_order_str: - before_order, err = _resolve_order(session, ts, before_order_str) - if err: - abort_with_error(404, err) + "The 'commit' parameter cannot be combined with " + "'after_commit' or 'before_commit'") + + commit = None + if commit_str: + commit = lookup_commit(session, ts, commit_str) + + after_commit = None + if after_commit_str: + after_commit = lookup_commit(session, ts, after_commit_str) + if after_commit.ordinal is None: + abort_with_error( + 400, "Commit '%s' has no ordinal; cannot use as " + "range boundary" % after_commit_str) + + before_commit = None + if before_commit_str: + before_commit = lookup_commit(session, ts, before_commit_str) + if before_commit.ordinal is None: + abort_with_error( + 400, "Commit '%s' has no ordinal; cannot use as " + "range boundary" % before_commit_str) after_time = None if after_time_str: @@ -456,9 +404,9 @@ def post(self, query_args, testsuite): # ------------------------------------------------------------------ # Execute query # ------------------------------------------------------------------ - items, has_next = _query_for_field( - session, ts, field, machine, test_ids, - sort_spec, cursor_values, order, after_order, before_order, + items, has_next = _build_query( + session, ts, metric_col, field_name, machine, test_ids, + sort_spec, cursor_values, commit, after_commit, before_commit, after_time, before_time, limit) # ------------------------------------------------------------------ @@ -467,15 +415,11 @@ def post(self, query_args, testsuite): next_cursor = None if has_next and items: last = items[-1] - cursor_vals = _extract_cursor_values(sort_spec, ts, { + cursor_vals = _extract_cursor_values(sort_spec, { 'test_name': last['test'], - 'order_id': last['_order_id'], - 'timestamp': last['timestamp'], + 'ordinal': last['ordinal'], + 'submitted_at': last['submitted_at'], }) next_cursor = _encode_cursor(cursor_vals) - # Strip internal fields before returning. - for item in items: - item.pop('_order_id', None) - return jsonify(make_paginated_response(items, next_cursor)) diff --git a/lnt/server/api/v5/schemas/query.py b/lnt/server/api/v5/schemas/query.py index a08317889..f6a85d82c 100644 --- a/lnt/server/api/v5/schemas/query.py +++ b/lnt/server/api/v5/schemas/query.py @@ -24,22 +24,24 @@ class QueryDataPointSchema(BaseSchema): required=True, metadata={'description': 'The sample value for the field'}, ) - order = ma.fields.Dict( - keys=ma.fields.String(), - values=ma.fields.String(), + commit = ma.fields.String( required=True, metadata={ - 'description': 'Order field values (e.g. llvm_project_revision)', - 'example': {'llvm_project_revision': 'abc123'}, + 'description': 'Commit identity string (e.g. revision hash)', + 'example': 'abc123', }, ) + ordinal = ma.fields.Integer( + allow_none=True, + metadata={'description': 'Commit ordinal position (may be null)'}, + ) run_uuid = ma.fields.String( required=True, metadata={'description': 'UUID of the run this data point belongs to'}, ) - timestamp = ma.fields.String( + submitted_at = ma.fields.String( allow_none=True, - metadata={'description': 'Run start time (ISO 8601)'}, + metadata={'description': 'Run submission time (ISO 8601)'}, ) @@ -79,17 +81,17 @@ class Meta: required=True, metadata={'description': 'Metric name (required)'}, ) - order = ma.fields.String( + commit = ma.fields.String( load_default=None, - metadata={'description': 'Filter by exact order value (mutually exclusive with after_order/before_order)'}, + metadata={'description': 'Filter by exact commit (mutually exclusive with after_commit/before_commit)'}, ) - after_order = ma.fields.String( + after_commit = ma.fields.String( load_default=None, - metadata={'description': 'Only return data points after this order value'}, + metadata={'description': 'Only return data points after this commit (by ordinal)'}, ) - before_order = ma.fields.String( + before_commit = ma.fields.String( load_default=None, - metadata={'description': 'Only return data points before this order value'}, + metadata={'description': 'Only return data points before this commit (by ordinal)'}, ) after_time = ma.fields.String( load_default=None, @@ -101,7 +103,8 @@ class Meta: ) sort = ma.fields.String( load_default=None, - metadata={'description': 'Comma-separated sort fields: test, order, timestamp (prefix with - for descending)'}, + metadata={'description': 'Comma-separated sort fields: test, commit, ' + 'submitted_at (prefix with - for descending)'}, ) limit = ma.fields.Integer( load_default=100, diff --git a/tests/server/api/v5/test_query.py b/tests/server/api/v5/test_query.py index 871f0b642..1c5aeac4e 100644 --- a/tests/server/api/v5/test_query.py +++ b/tests/server/api/v5/test_query.py @@ -2,10 +2,11 @@ # # RUN: rm -rf %t.instance %t.pg.log # RUN: %{utils}/with_postgres.sh %t.pg.log \ -# RUN: %{utils}/with_temporary_instance.py %t.instance \ +# RUN: %{utils}/with_temporary_instance.py --db-version 5.0 %t.instance \ # RUN: -- python %s %t.instance # END. +import datetime import random import sys import os @@ -13,35 +14,50 @@ import uuid sys.path.insert(0, os.path.dirname(__file__)) -from v5_test_helpers import ( - create_app, create_client, submit_run, -) +from v5_test_helpers import create_app, create_client, set_ordinal, submit_run TS = 'nts' PREFIX = f'/api/v5/{TS}' -def _setup_query_data(client, machine_name, test_name, num_points=5): +def _setup_query_data(client, app, machine_name, test_name, num_points=5): """Create a machine, test, and several runs with samples. Returns a dict with the created entities for assertions. """ rev_prefix = uuid.uuid4().hex[:6] + # Use a random base to avoid ordinal collisions across test classes. + ordinal_base = int(uuid.uuid4().hex[:6], 16) run_uuids = [] + commits = [] for i in range(num_points): + commit_str = f'{100 + i}-{rev_prefix}' data = submit_run( - client, machine_name, f'{100 + i}-{rev_prefix}', - [{'name': test_name, 'execution_time': [float(i + 1) * 1.5]}], - start_time=f'2024-01-{1 + i:02d}T12:00:00', - end_time=f'2024-01-{1 + i:02d}T12:30:00', - ) + client, machine_name, commit_str, + [{'name': test_name, 'execution_time': [float(i + 1) * 1.5]}]) run_uuids.append(data['run_uuid']) + commits.append(commit_str) + + # Assign ordinals via API (D11: ordinals set exclusively via PATCH) + for i, commit_str in enumerate(commits): + set_ordinal(client, commit_str, ordinal_base + i) + + # Set sequential timestamps via direct DB (no API for submitted_at) + db = app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + for i, run_uuid in enumerate(run_uuids): + run = ts.get_run(session, uuid=run_uuid) + run.submitted_at = datetime.datetime(2024, 1, 1 + i, 12, 0, 0) + session.commit() + session.close() return { 'machine': machine_name, 'test': test_name, 'run_uuids': run_uuids, 'num_points': num_points, + 'commits': commits, } @@ -103,6 +119,7 @@ def setUpClass(cls): unique = uuid.uuid4().hex[:8] cls._data = _setup_query_data( cls.client, + cls.app, machine_name=f'series-valid-m-{unique}', test_name=f'series-valid-t/{unique}', num_points=5, @@ -136,26 +153,25 @@ def test_data_point_structure(self): self.assertIn('machine', item) self.assertIn('metric', item) self.assertIn('value', item) - self.assertIn('order', item) + self.assertIn('commit', item) self.assertIn('run_uuid', item) - self.assertIn('timestamp', item) + self.assertIn('submitted_at', item) self.assertIsInstance(item['value'], (int, float)) - self.assertIsInstance(item['order'], dict) + self.assertIsInstance(item['commit'], str) self.assertIsInstance(item['run_uuid'], str) self.assertEqual(item['test'], d['test']) self.assertEqual(item['machine'], d['machine']) self.assertEqual(item['metric'], 'execution_time') - def test_order_has_field_names(self): - """Order dict should contain order field names as keys.""" + def test_commit_is_a_string(self): + """Commit field should be a plain string (not a dict).""" d = self._data resp = self.client.post( PREFIX + '/query', json={'machine': d['machine'], 'test': [d['test']], 'metric': 'execution_time'}) data = resp.get_json() for item in data['items']: - # NTS suite has llvm_project_revision - self.assertIn('llvm_project_revision', item['order']) + self.assertIsInstance(item['commit'], str) def test_run_uuids_are_valid(self): """All run_uuid values should be from the runs we created.""" @@ -239,39 +255,40 @@ def setUpClass(cls): mname = f'query-order-m-{unique}' tname = f'query-order-t/{unique}' - # Create orders in sequential revision order so Order.id matches + # Create orders in sequential revision order revisions = ['100', '200', '300', '400', '500'] rev_prefix = uuid.uuid4().hex[:6] for rev in revisions: submit_run( cls.client, mname, f'{rev}-{rev_prefix}', [{'name': tname, 'execution_time': [float(rev)]}], - start_time='2024-01-01T12:00:00', - end_time='2024-01-01T12:30:00', ) + # Assign ordinals via API (D11: ordinals set exclusively via PATCH) + ordinal_base = int(uuid.uuid4().hex[:6], 16) + for i, rev in enumerate(revisions): + commit_str = f'{rev}-{rev_prefix}' + set_ordinal(cls.client, commit_str, ordinal_base + i) + cls._data = { 'machine': mname, 'test': tname, 'expected_revisions': [f'{r}-{rev_prefix}' for r in revisions], } - def test_data_sorted_by_order(self): - """Data points should be sorted by order (revision) value.""" + def test_data_sorted_by_ordinal(self): + """Data points should be sorted by ordinal value.""" d = self._data resp = self.client.post( PREFIX + '/query', json={'machine': d['machine'], 'test': [d['test']], 'metric': 'execution_time'}) data = resp.get_json() - revisions = [ - item['order']['llvm_project_revision'] - for item in data['items'] - ] - self.assertEqual(revisions, d['expected_revisions']) + ordinals = [item['ordinal'] for item in data['items']] + self.assertEqual(ordinals, sorted(ordinals)) class TestQueryRangeFilters(unittest.TestCase): - """Tests for after_order/before_order and after_time/before_time filtering.""" + """Tests for after_commit/before_commit and after_time/before_time filtering.""" @classmethod def setUpClass(cls): @@ -282,80 +299,97 @@ def setUpClass(cls): mname = f'query-filter-m-{unique}' tname = f'query-filter-t/{unique}' + cls._commits = [] for i in range(10): rev = str(100 + i * 10) # 100, 110, ..., 190 submit_run( cls.client, mname, rev, [{'name': tname, 'execution_time': [float(100 + i * 10)]}], - start_time=f'2024-01-{1 + i:02d}T12:00:00', - end_time=f'2024-01-{1 + i:02d}T12:30:00', ) + cls._commits.append(rev) + + # Assign ordinals via API (D11: ordinals set exclusively via PATCH) + ordinal_base = int(uuid.uuid4().hex[:6], 16) + for i, commit_str in enumerate(cls._commits): + set_ordinal(cls.client, commit_str, ordinal_base + i) + + # Set sequential timestamps via direct DB (no API for submitted_at) + db = cls.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + for i, commit_str in enumerate(cls._commits): + c = ts.get_commit(session, commit=commit_str) + runs = ts.list_runs(session, commit_id=c.id) + for run in runs: + run.submitted_at = datetime.datetime(2024, 1, 1 + i, 12, 0, 0) + session.commit() + session.close() cls._data = { 'machine': mname, 'test': tname, } - def test_after_order_filter(self): - """Only data points after the given order should be returned.""" + def test_after_commit_filter(self): + """Only data points after the given commit should be returned.""" d = self._data resp = self.client.post( PREFIX + '/query', json={'machine': d['machine'], 'test': [d['test']], - 'metric': 'execution_time', 'after_order': '150'}) + 'metric': 'execution_time', 'after_commit': '150'}) self.assertEqual(resp.status_code, 200, resp.get_json()) data = resp.get_json() self.assertGreater(len(data['items']), 0) for item in data['items']: - rev = int(item['order']['llvm_project_revision']) + rev = int(item['commit']) self.assertGreater(rev, 150) - def test_before_order_filter(self): - """Only data points before the given order should be returned.""" + def test_before_commit_filter(self): + """Only data points before the given commit should be returned.""" d = self._data resp = self.client.post( PREFIX + '/query', json={'machine': d['machine'], 'test': [d['test']], - 'metric': 'execution_time', 'before_order': '150'}) + 'metric': 'execution_time', 'before_commit': '150'}) self.assertEqual(resp.status_code, 200, resp.get_json()) data = resp.get_json() self.assertGreater(len(data['items']), 0) for item in data['items']: - rev = int(item['order']['llvm_project_revision']) + rev = int(item['commit']) self.assertLess(rev, 150) - def test_after_order_and_before_order_combined(self): - """Combining after_order and before_order narrows the range.""" + def test_after_commit_and_before_commit_combined(self): + """Combining after_commit and before_commit narrows the range.""" d = self._data resp = self.client.post( PREFIX + '/query', json={'machine': d['machine'], 'test': [d['test']], - 'metric': 'execution_time', 'after_order': '120', - 'before_order': '170'}) + 'metric': 'execution_time', 'after_commit': '120', + 'before_commit': '170'}) self.assertEqual(resp.status_code, 200, resp.get_json()) data = resp.get_json() for item in data['items']: - rev = int(item['order']['llvm_project_revision']) + rev = int(item['commit']) self.assertGreater(rev, 120) self.assertLess(rev, 170) self.assertGreater(len(data['items']), 0) - def test_after_order_nonexistent_returns_404(self): - """Filtering with a non-existent order value returns 404.""" + def test_after_commit_nonexistent_returns_404(self): + """Filtering with a non-existent commit value returns 404.""" d = self._data resp = self.client.post( PREFIX + '/query', json={'machine': d['machine'], 'test': [d['test']], - 'metric': 'execution_time', 'after_order': '999999'}) + 'metric': 'execution_time', 'after_commit': '999999'}) self.assertEqual(resp.status_code, 404) - def test_before_order_nonexistent_returns_404(self): - """Filtering with a non-existent order value returns 404.""" + def test_before_commit_nonexistent_returns_404(self): + """Filtering with a non-existent commit value returns 404.""" d = self._data resp = self.client.post( PREFIX + '/query', json={'machine': d['machine'], 'test': [d['test']], - 'metric': 'execution_time', 'before_order': '999999'}) + 'metric': 'execution_time', 'before_commit': '999999'}) self.assertEqual(resp.status_code, 404) def test_after_time_filter(self): @@ -370,7 +404,7 @@ def test_after_time_filter(self): data = resp.get_json() self.assertGreater(len(data['items']), 0) for item in data['items']: - self.assertGreater(item['timestamp'], '2024-01-06T00:00:00') + self.assertGreater(item['submitted_at'], '2024-01-06T00:00:00') def test_before_time_filter(self): """Only data points from runs before the given time should be returned.""" @@ -384,7 +418,7 @@ def test_before_time_filter(self): data = resp.get_json() self.assertGreater(len(data['items']), 0) for item in data['items']: - self.assertLess(item['timestamp'], '2024-01-04T00:00:00') + self.assertLess(item['submitted_at'], '2024-01-04T00:00:00') def test_after_time_and_before_time_combined(self): """Combining time range filters narrows the results.""" @@ -399,24 +433,24 @@ def test_after_time_and_before_time_combined(self): data = resp.get_json() self.assertGreater(len(data['items']), 0) for item in data['items']: - self.assertGreater(item['timestamp'], '2024-01-03T00:00:00') - self.assertLess(item['timestamp'], '2024-01-07T00:00:00') + self.assertGreater(item['submitted_at'], '2024-01-03T00:00:00') + self.assertLess(item['submitted_at'], '2024-01-07T00:00:00') - def test_order_and_time_filters_compose(self): - """Both order and time filters can be used together.""" + def test_commit_and_time_filters_compose(self): + """Both commit and time filters can be used together.""" d = self._data resp = self.client.post( PREFIX + '/query', json={'machine': d['machine'], 'test': [d['test']], 'metric': 'execution_time', - 'after_order': '120', + 'after_commit': '120', 'before_time': '2024-01-07T00:00:00'}) self.assertEqual(resp.status_code, 200, resp.get_json()) data = resp.get_json() for item in data['items']: - rev = int(item['order']['llvm_project_revision']) + rev = int(item['commit']) self.assertGreater(rev, 120) - self.assertLess(item['timestamp'], '2024-01-07T00:00:00') + self.assertLess(item['submitted_at'], '2024-01-07T00:00:00') def test_after_time_future_returns_empty(self): """Filtering with after_time far in the future returns 0 items.""" @@ -454,6 +488,7 @@ def setUpClass(cls): unique = uuid.uuid4().hex[:8] cls._data = _setup_query_data( cls.client, + cls.app, machine_name=f'series-limit-m-{unique}', test_name=f'series-limit-t/{unique}', num_points=10, @@ -501,6 +536,7 @@ def setUpClass(cls): unique = uuid.uuid4().hex[:8] cls._data = _setup_query_data( cls.client, + cls.app, machine_name=f'series-page-m-{unique}', test_name=f'series-page-t/{unique}', num_points=7, @@ -572,28 +608,44 @@ def test_invalid_cursor_returns_400(self): self.assertEqual(resp.status_code, 400) -def _setup_multi_test_data(client, machine_name, test_names, num_orders=5): +def _setup_multi_test_data(client, app, machine_name, test_names, num_orders=5): """Create a machine, multiple tests, and samples for each.""" - # Use a random base offset to avoid revision collisions across test - # classes while keeping revisions parseable as plain integers (some - # tests assert ordering via int()). base = random.randint(100000, 999000) + ordinal_base = int(uuid.uuid4().hex[:6], 16) + commits = [] for i in range(num_orders): tests = [ {'name': tn, 'execution_time': [float((i + 1) * 10 + j)]} for j, tn in enumerate(test_names) ] + commit_str = str(base + i) submit_run( - client, machine_name, str(base + i), + client, machine_name, commit_str, tests, - start_time=f'2024-06-{1 + i:02d}T12:00:00', - end_time=f'2024-06-{1 + i:02d}T12:30:00', ) + commits.append(commit_str) + + # Assign ordinals via API (D11: ordinals set exclusively via PATCH) + for i, commit_str in enumerate(commits): + set_ordinal(client, commit_str, ordinal_base + i) + + # Set sequential timestamps via direct DB (no API for submitted_at) + db = app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + for i, commit_str in enumerate(commits): + c = ts.get_commit(session, commit=commit_str) + runs = ts.list_runs(session, commit_id=c.id) + for run in runs: + run.submitted_at = datetime.datetime(2024, 6, 1 + i, 12, 0, 0) + session.commit() + session.close() return { 'machine': machine_name, 'test_names': test_names, 'num_orders': num_orders, + 'commits': commits, } @@ -608,6 +660,7 @@ def setUpClass(cls): unique = uuid.uuid4().hex[:8] cls._data = _setup_multi_test_data( cls.client, + cls.app, machine_name=f'query-opt-m-{unique}', test_names=[f'query-opt-t1/{unique}', f'query-opt-t2/{unique}', @@ -679,6 +732,7 @@ def setUpClass(cls): unique = uuid.uuid4().hex[:8] cls._data = _setup_multi_test_data( cls.client, + cls.app, machine_name=f'query-shape-m-{unique}', test_names=[f'query-shape-t/{unique}'], num_orders=3, @@ -687,7 +741,7 @@ def setUpClass(cls): def _assert_item_shape(self, item): """Assert a single item has all required fields.""" for key in ('test', 'machine', 'metric', - 'value', 'order', 'run_uuid', 'timestamp'): + 'value', 'commit', 'run_uuid', 'submitted_at'): self.assertIn(key, item, f"Missing key: {key}") def test_items_with_all_filters(self): @@ -723,6 +777,7 @@ def setUpClass(cls): unique = uuid.uuid4().hex[:8] cls._data = _setup_multi_test_data( cls.client, + cls.app, machine_name=f'query-mtp-m-{unique}', test_names=[f'query-mtp-t1/{unique}', f'query-mtp-t2/{unique}', @@ -767,7 +822,7 @@ def test_no_duplicates_across_pages(self): resp = self.client.post(PREFIX + '/query', json=params) data = resp.get_json() all_keys.extend( - (item['test'], item['order']['llvm_project_revision']) + (item['test'], item['commit']) for item in data['items']) cursor = data['cursor']['next'] @@ -777,7 +832,7 @@ def test_no_duplicates_across_pages(self): PREFIX + '/query', json={**params, 'cursor': cursor}) data = resp.get_json() all_keys.extend( - (item['test'], item['order']['llvm_project_revision']) + (item['test'], item['commit']) for item in data['items']) cursor = data['cursor']['next'] pages += 1 @@ -798,6 +853,7 @@ def setUpClass(cls): unique = uuid.uuid4().hex[:8] cls._data = _setup_multi_test_data( cls.client, + cls.app, machine_name=f'query-sort-m-{unique}', test_names=[f'query-sort-a/{unique}', f'query-sort-b/{unique}', @@ -805,41 +861,41 @@ def setUpClass(cls): num_orders=3, ) - def test_sort_by_test_order(self): - """sort=test,order groups results by test name.""" + def test_sort_by_test_commit(self): + """sort=test,commit groups results by test name.""" d = self._data resp = self.client.post( PREFIX + '/query', json={'machine': d['machine'], - 'metric': 'execution_time', 'sort': 'test,order'}) + 'metric': 'execution_time', 'sort': 'test,commit'}) data = resp.get_json() test_names = [item['test'] for item in data['items']] self.assertEqual(test_names, sorted(test_names)) - def test_sort_by_order_test(self): - """sort=order,test is the default ordering.""" + def test_sort_by_commit_test(self): + """sort=commit,test is the default ordering.""" d = self._data resp = self.client.post( PREFIX + '/query', json={'machine': d['machine'], - 'metric': 'execution_time', 'sort': 'order,test'}) + 'metric': 'execution_time', 'sort': 'commit,test'}) data = resp.get_json() - # Items should be grouped by order + # Items should be grouped by commit self.assertGreater(len(data['items']), 0) def test_sort_descending(self): - """-order,test returns newest orders first.""" + """-commit,test returns newest commits first.""" d = self._data resp = self.client.post( PREFIX + '/query', json={'machine': d['machine'], 'test': [d['test_names'][0]], - 'metric': 'execution_time', 'sort': '-order'}) + 'metric': 'execution_time', 'sort': '-commit'}) data = resp.get_json() - revisions = [ - item['order']['llvm_project_revision'] + commits = [ + item['commit'] for item in data['items'] ] - self.assertEqual(revisions, sorted(revisions, reverse=True)) + self.assertEqual(commits, sorted(commits, reverse=True)) def test_sort_invalid_field_returns_400(self): resp = self.client.post( @@ -852,7 +908,7 @@ def test_sort_with_pagination(self): d = self._data all_test_names = [] params = {'machine': d['machine'], - 'metric': 'execution_time', 'sort': 'test,order', + 'metric': 'execution_time', 'sort': 'test,commit', 'limit': 4} resp = self.client.post(PREFIX + '/query', json=params) @@ -885,18 +941,19 @@ def setUpClass(cls): unique = uuid.uuid4().hex[:8] cls._data = _setup_multi_test_data( cls.client, + cls.app, machine_name=f'query-mixed-m-{unique}', test_names=[f'query-mixed-a/{unique}', f'query-mixed-b/{unique}'], num_orders=5, ) - def test_desc_order_pagination_collects_all(self): - """Paginating with -order,test collects all items.""" + def test_desc_commit_pagination_collects_all(self): + """Paginating with -commit,test collects all items.""" d = self._data all_items = [] params = {'machine': d['machine'], - 'metric': 'execution_time', 'sort': '-order,test', + 'metric': 'execution_time', 'sort': '-commit,test', 'limit': 3} resp = self.client.post(PREFIX + '/query', json=params) self.assertEqual(resp.status_code, 200, resp.get_json()) @@ -917,17 +974,17 @@ def test_desc_order_pagination_collects_all(self): expected = len(d['test_names']) * d['num_orders'] self.assertEqual(len(all_items), expected) - def test_desc_order_pagination_no_duplicates(self): - """No duplicates across pages with -order,test.""" + def test_desc_commit_pagination_no_duplicates(self): + """No duplicates across pages with -commit,test.""" d = self._data all_keys = [] params = {'machine': d['machine'], - 'metric': 'execution_time', 'sort': '-order,test', + 'metric': 'execution_time', 'sort': '-commit,test', 'limit': 3} resp = self.client.post(PREFIX + '/query', json=params) data = resp.get_json() all_keys.extend( - (item['test'], item['order']['llvm_project_revision']) + (item['test'], item['commit']) for item in data['items']) cursor = data['cursor']['next'] pages = 1 @@ -936,7 +993,7 @@ def test_desc_order_pagination_no_duplicates(self): PREFIX + '/query', json={**params, 'cursor': cursor}) data = resp.get_json() all_keys.extend( - (item['test'], item['order']['llvm_project_revision']) + (item['test'], item['commit']) for item in data['items']) cursor = data['cursor']['next'] pages += 1 @@ -944,19 +1001,19 @@ def test_desc_order_pagination_no_duplicates(self): break self.assertEqual(len(all_keys), len(set(all_keys))) - def test_desc_order_is_actually_descending(self): - """Results with -order are in descending order.""" + def test_desc_commit_is_actually_descending(self): + """Results with -commit are in descending order.""" d = self._data resp = self.client.post( PREFIX + '/query', json={'machine': d['machine'], 'test': [d['test_names'][0]], - 'metric': 'execution_time', 'sort': '-order'}) + 'metric': 'execution_time', 'sort': '-commit'}) data = resp.get_json() - revisions = [ - int(item['order']['llvm_project_revision']) + commits = [ + int(item['commit']) for item in data['items'] ] - self.assertEqual(revisions, sorted(revisions, reverse=True)) + self.assertEqual(commits, sorted(commits, reverse=True)) class TestQueryMalformedTimestamp(unittest.TestCase): @@ -997,13 +1054,19 @@ def setUpClass(cls): mname = f'query-mreq-m-{unique}' tname = f'query-mreq-t/{unique}' rev_prefix = uuid.uuid4().hex[:6] + commits = [] for i in range(3): + commit_str = f'{2000 + i}-{rev_prefix}' submit_run( - cls.client, mname, f'{2000 + i}-{rev_prefix}', + cls.client, mname, commit_str, [{'name': tname, 'execution_time': [float(i + 1)]}], - start_time=f'2024-06-{1 + i:02d}T12:00:00', - end_time=f'2024-06-{1 + i:02d}T12:30:00', ) + commits.append(commit_str) + + # Assign ordinals via API (D11: ordinals set exclusively via PATCH) + ordinal_base = int(uuid.uuid4().hex[:6], 16) + for i, cs in enumerate(commits): + set_ordinal(cls.client, cs, ordinal_base + i) cls._data = {'machine': mname, 'test': tname} def test_omitting_metric_returns_422(self): @@ -1028,7 +1091,7 @@ def test_with_metric_returns_200(self): class TestQueryOrderRangeBoundaries(unittest.TestCase): - """Test boundary conditions for order range filters.""" + """Test boundary conditions for commit range filters.""" @classmethod def setUpClass(cls): @@ -1038,99 +1101,116 @@ def setUpClass(cls): unique = uuid.uuid4().hex[:8] mname = f'query-orb-m-{unique}' tname = f'query-orb-t/{unique}' + cls._commits = [] for i in range(5): rev = str(3000 + i * 10) # 3000, 3010, 3020, 3030, 3040 submit_run( cls.client, mname, rev, [{'name': tname, 'execution_time': [float(3000 + i * 10)]}], - start_time=f'2024-07-{1 + i:02d}T12:00:00', - end_time=f'2024-07-{1 + i:02d}T12:30:00', ) + cls._commits.append(rev) + + # Assign ordinals via API (D11: ordinals set exclusively via PATCH) + ordinal_base = int(uuid.uuid4().hex[:6], 16) + for i, commit_str in enumerate(cls._commits): + set_ordinal(cls.client, commit_str, ordinal_base + i) + + # Set sequential timestamps via direct DB (no API for submitted_at) + db = cls.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + for i, commit_str in enumerate(cls._commits): + c = ts.get_commit(session, commit=commit_str) + runs = ts.list_runs(session, commit_id=c.id) + for run in runs: + run.submitted_at = datetime.datetime(2024, 7, 1 + i, 12, 0, 0) + session.commit() + session.close() + cls._data = {'machine': mname, 'test': tname} - def test_same_after_and_before_order_returns_empty(self): + def test_same_after_and_before_commit_returns_empty(self): d = self._data resp = self.client.post( PREFIX + '/query', json={'machine': d['machine'], 'test': [d['test']], - 'metric': 'execution_time', 'after_order': '3020', - 'before_order': '3020'}) + 'metric': 'execution_time', 'after_commit': '3020', + 'before_commit': '3020'}) self.assertEqual(resp.status_code, 200, resp.get_json()) data = resp.get_json() self.assertEqual(len(data['items']), 0) - def test_inverted_order_range_returns_empty(self): + def test_inverted_commit_range_returns_empty(self): d = self._data resp = self.client.post( PREFIX + '/query', json={'machine': d['machine'], 'test': [d['test']], - 'metric': 'execution_time', 'after_order': '3040', - 'before_order': '3000'}) + 'metric': 'execution_time', 'after_commit': '3040', + 'before_commit': '3000'}) self.assertEqual(resp.status_code, 200, resp.get_json()) data = resp.get_json() self.assertEqual(len(data['items']), 0) - def test_exact_order_filter(self): - """The order param returns data at exactly that order.""" + def test_exact_commit_filter(self): + """The commit param returns data at exactly that commit.""" d = self._data resp = self.client.post( PREFIX + '/query', json={'machine': d['machine'], 'test': [d['test']], - 'metric': 'execution_time', 'order': '3020'}) + 'metric': 'execution_time', 'commit': '3020'}) self.assertEqual(resp.status_code, 200, resp.get_json()) data = resp.get_json() self.assertEqual(len(data['items']), 1) - self.assertEqual( - data['items'][0]['order']['llvm_project_revision'], '3020') + self.assertEqual(data['items'][0]['commit'], '3020') - def test_exact_order_nonexistent_returns_404(self): + def test_exact_commit_nonexistent_returns_404(self): d = self._data resp = self.client.post( PREFIX + '/query', json={'machine': d['machine'], 'test': [d['test']], - 'metric': 'execution_time', 'order': '999999'}) + 'metric': 'execution_time', 'commit': '999999'}) self.assertEqual(resp.status_code, 404) - def test_order_with_after_order_returns_400(self): + def test_commit_with_after_commit_returns_400(self): d = self._data resp = self.client.post( PREFIX + '/query', json={'machine': d['machine'], 'test': [d['test']], - 'metric': 'execution_time', 'order': '3020', - 'after_order': '3000'}) + 'metric': 'execution_time', 'commit': '3020', + 'after_commit': '3000'}) self.assertEqual(resp.status_code, 400) - def test_order_with_before_order_returns_400(self): + def test_commit_with_before_commit_returns_400(self): d = self._data resp = self.client.post( PREFIX + '/query', json={'machine': d['machine'], 'test': [d['test']], - 'metric': 'execution_time', 'order': '3020', - 'before_order': '3040'}) + 'metric': 'execution_time', 'commit': '3020', + 'before_commit': '3040'}) self.assertEqual(resp.status_code, 400) - def test_exact_order_with_time_filter(self): - """The order param can be combined with time filters.""" + def test_exact_commit_with_time_filter(self): + """The commit param can be combined with time filters.""" d = self._data resp = self.client.post( PREFIX + '/query', json={'machine': d['machine'], 'test': [d['test']], - 'metric': 'execution_time', 'order': '3020', + 'metric': 'execution_time', 'commit': '3020', 'after_time': '2024-07-01T00:00:00', 'before_time': '2024-07-10T00:00:00'}) self.assertEqual(resp.status_code, 200, resp.get_json()) data = resp.get_json() self.assertEqual(len(data['items']), 1) - def test_exact_order_no_samples_for_machine(self): - """Order exists but has no data for the given machine — 200 empty.""" + def test_exact_commit_no_samples_for_machine(self): + """Commit exists but has no data for the given machine -- 200 empty.""" d = self._data resp = self.client.post( PREFIX + '/query', json={'machine': 'nonexistent-machine-' + d['machine'], 'test': [d['test']], 'metric': 'execution_time', - 'order': '3020'}) - # Machine doesn't exist → 404 from _resolve_machine + 'commit': '3020'}) + # Machine doesn't exist -> 404 from _resolve_machine self.assertEqual(resp.status_code, 404) @@ -1145,6 +1225,7 @@ def setUpClass(cls): unique = uuid.uuid4().hex[:8] cls._data = _setup_query_data( cls.client, + cls.app, machine_name=f'query-limb-m-{unique}', test_name=f'query-limb-t/{unique}', num_points=5, @@ -1201,6 +1282,7 @@ def setUpClass(cls): unique = uuid.uuid4().hex[:8] cls._data = _setup_query_data( cls.client, + cls.app, machine_name=f'query-cec-m-{unique}', test_name=f'query-cec-t/{unique}', num_points=3, @@ -1210,7 +1292,7 @@ def test_cursor_wrong_field_count_returns_400(self): """Cursor with wrong number of fields should be rejected.""" import base64 import json - # Default sort is order,test -> 2 fields. Encode 3 fields. + # Default sort is commit,test -> 2 fields. Encode 3 fields. bad_cursor = base64.urlsafe_b64encode( json.dumps([1, "x", "extra"]).encode()).decode() d = self._data @@ -1221,20 +1303,20 @@ def test_cursor_wrong_field_count_returns_400(self): self.assertEqual(resp.status_code, 400) def test_cursor_from_different_sort_order_is_rejected(self): - """Cursor from sort=order,test used with sort=test,order should fail + """Cursor from sort=commit,test used with sort=test,commit should fail gracefully since the cursor values don't match the sort columns.""" d = self._data - # Get cursor from sort=order,test (default) + # Get cursor from sort=commit,test (default) resp = self.client.post( PREFIX + '/query', json={'machine': d['machine'], 'test': [d['test']], 'metric': 'execution_time', 'limit': 1}) cursor = resp.get_json()['cursor']['next'] - # Use with sort=test,order — mismatched cursor + # Use with sort=test,commit -- mismatched cursor resp2 = self.client.post( PREFIX + '/query', json={'machine': d['machine'], 'test': [d['test']], - 'metric': 'execution_time', 'sort': 'test,order', + 'metric': 'execution_time', 'sort': 'test,commit', 'cursor': cursor}) self.assertEqual(resp2.status_code, 400) @@ -1251,14 +1333,14 @@ def setUpClass(cls): def test_sort_duplicate_field_is_deduplicated(self): resp = self.client.post( PREFIX + '/query', - json={'metric': 'execution_time', 'sort': 'order,order,test'}) + json={'metric': 'execution_time', 'sort': 'commit,commit,test'}) self.assertEqual(resp.status_code, 200) def test_sort_empty_string_uses_default(self): resp = self.client.post( PREFIX + '/query', json={'metric': 'execution_time', 'sort': ''}) - # Empty sort string should use default (order,test) + # Empty sort string should use default (commit,test) self.assertEqual(resp.status_code, 200) def test_sort_dash_invalid_field_returns_400(self): @@ -1332,7 +1414,7 @@ def test_400_malformed_time_has_error_format(self): class TestQueryNoInternalFieldsLeak(unittest.TestCase): - """Test that no internal fields (like _order_id) leak in response.""" + """Test that no internal fields (starting with _) leak in response.""" @classmethod def setUpClass(cls): @@ -1342,6 +1424,7 @@ def setUpClass(cls): unique = uuid.uuid4().hex[:8] cls._data = _setup_query_data( cls.client, + cls.app, machine_name=f'query-noleak-m-{unique}', test_name=f'query-noleak-t/{unique}', num_points=3, @@ -1371,6 +1454,7 @@ def setUpClass(cls): unique = uuid.uuid4().hex[:8] cls._data = _setup_query_data( cls.client, + cls.app, machine_name=f'query-unknown-m-{unique}', test_name=f'query-unknown-t/{unique}', num_points=3, @@ -1436,7 +1520,7 @@ def test_valid_params_still_work(self): resp = self.client.post( PREFIX + '/query', json={'machine': d['machine'], 'test': [d['test']], - 'metric': 'execution_time', 'sort': 'order', + 'metric': 'execution_time', 'sort': 'commit', 'limit': 10}) self.assertEqual(resp.status_code, 200) data = resp.get_json() @@ -1468,10 +1552,14 @@ def setUpClass(cls): submit_run( cls.client, cls.machine_name, f'{500 + i}-{rev_prefix}', [{'name': tname, 'execution_time': [float(i + 1) * 2.0]}], - start_time=f'2024-06-{1 + i:02d}T12:00:00', - end_time=f'2024-06-{1 + i:02d}T12:30:00', ) + # Assign ordinals via API (D11: ordinals set exclusively via PATCH) + ordinal_base = int(uuid.uuid4().hex[:6], 16) + for i in range(3): + set_ordinal(cls.client, f'{500 + i}-{rev_prefix}', + ordinal_base + i) + def test_single_test_param_returns_only_that_test(self): resp = self.client.post( PREFIX + '/query', diff --git a/tests/server/api/v5/v5_test_helpers.py b/tests/server/api/v5/v5_test_helpers.py index 42909e52f..2e9303e7e 100644 --- a/tests/server/api/v5/v5_test_helpers.py +++ b/tests/server/api/v5/v5_test_helpers.py @@ -156,6 +156,17 @@ def collect_all_pages(test_case, client, url, page_limit=20): # API-based fixture helpers # --------------------------------------------------------------------------- +def set_ordinal(client, commit, ordinal, testsuite='nts'): + """Assign an ordinal to a commit via PATCH /commits/{value}.""" + resp = client.patch( + f'/api/v5/{testsuite}/commits/{commit}', + json={'ordinal': ordinal}, + headers=admin_headers(), + ) + assert resp.status_code == 200, \ + "set_ordinal(%s, %d) failed: %s" % (commit, ordinal, resp.data) + + def submit_run(client, machine_name, commit, tests, machine_info=None, testsuite='nts'): """Submit a run via POST and return response JSON (includes run_uuid).""" From 5fa486c805d35cb1fa08a1bae4853a6f40ad49f6 Mon Sep 17 00:00:00 2001 From: Louis Dionne Date: Tue, 14 Apr 2026 10:35:10 -0400 Subject: [PATCH 048/143] [Docs] Update stale Orders section to Commits in API design doc The Orders section (routes, description) was never updated when Orders were replaced by Commits. Update to reflect the actual v5 API: routes use /commits/{value}, PATCH supports ordinal assignment, DELETE is supported, and ordinals are NULL on creation per D11. Co-Authored-By: Claude Opus 4.6 (1M context) --- docs/design/v5-api.md | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) diff --git a/docs/design/v5-api.md b/docs/design/v5-api.md index 95ea0f6cd..ed78a0a37 100644 --- a/docs/design/v5-api.md +++ b/docs/design/v5-api.md @@ -28,14 +28,15 @@ DELETE /machines/{machine_name} — Delete machine and its runs GET /machines/{machine_name}/runs — List runs for this machine (cursor-paginated) Machines are also created implicitly if a run is submitted for a nonexistent machine. -Orders - -GET /orders — List (cursor-paginated, filterable) -POST /orders — Create with metadata (git commit info, etc.) -GET /orders/{order_id} — Detail (includes previous/next order references) -PATCH /orders/{order_id} — Update metadata -Orders are read/create/update only — no delete. The order_id in the path is the primary order field value (e.g. the revision hash). If order fields are multi-valued and ambiguous, query parameters -disambiguate. Orders are also created implicitly during run submission. +Commits + +GET /commits — List (cursor-paginated, searchable) +POST /commits — Create with metadata (commit_fields) +GET /commits/{value} — Detail (includes previous/next commit by ordinal) +PATCH /commits/{value} — Update ordinal and/or commit_fields +DELETE /commits/{value} — Delete commit (cascades to runs/samples; 409 if referenced by field changes) +The {value} in the path is the commit identity string. Commits are also created implicitly during run submission. +Ordinals are always NULL on creation and assigned exclusively via PATCH (see D11 in v5-db.md). Runs From 9bf151f171c614cbb39fc1857386ae713f656747 Mon Sep 17 00:00:00 2001 From: Louis Dionne Date: Tue, 14 Apr 2026 11:12:58 -0400 Subject: [PATCH 049/143] [Tests] Update 5 cross-cutting test files for v5 DB MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Add --db-version 5.0 to all RUN headers. Update v4 references: - test_access_log: /orders → /commits, llvm_project_revision → commit - test_integration: format_version '2' → '5', v4 run payload → v5 format, order dict → commit string, start_time/end_time → submitted_at, orders → commits in discovery links, use submit_run() test_auth, test_errors, test_etag needed only the --db-version flag. All 107/108 v5 tests pass (only test_profiles.py remains, deferred per D13). Co-Authored-By: Claude Opus 4.6 (1M context) --- tests/server/api/v5/test_access_log.py | 32 +++---- tests/server/api/v5/test_auth.py | 2 +- tests/server/api/v5/test_errors.py | 2 +- tests/server/api/v5/test_etag.py | 2 +- tests/server/api/v5/test_integration.py | 109 +++++++++--------------- 5 files changed, 60 insertions(+), 87 deletions(-) diff --git a/tests/server/api/v5/test_access_log.py b/tests/server/api/v5/test_access_log.py index 33060e4c6..2d8ca7d96 100644 --- a/tests/server/api/v5/test_access_log.py +++ b/tests/server/api/v5/test_access_log.py @@ -2,7 +2,7 @@ # # RUN: rm -rf %t.instance %t.pg.log # RUN: %{utils}/with_postgres.sh %t.pg.log \ -# RUN: %{utils}/with_temporary_instance.py %t.instance \ +# RUN: %{utils}/with_temporary_instance.py --db-version 5.0 %t.instance \ # RUN: -- python %s %t.instance # END. @@ -78,27 +78,27 @@ class TestAccessLogFormat(_AccessLogTestCase): """Verify the access log emits valid Apache combined format.""" def test_log_line_matches_combined_format(self): - self.client.get(PREFIX + '/orders') + self.client.get(PREFIX + '/commits') self.assertEqual(len(self.capture.lines), 1) m = COMBINED_RE.match(self.capture.lines[0]) self.assertIsNotNone(m, f'Log line does not match combined format: ' f'{self.capture.lines[0]!r}') def test_method_and_path(self): - self.client.get(PREFIX + '/orders') + self.client.get(PREFIX + '/commits') m = COMBINED_RE.match(self.capture.lines[0]) self.assertEqual(m.group('method'), 'GET') - self.assertIn('/api/v5/nts/orders', m.group('path')) + self.assertIn('/api/v5/nts/commits', m.group('path')) def test_status_code_200(self): - self.client.get(PREFIX + '/orders') + self.client.get(PREFIX + '/commits') m = COMBINED_RE.match(self.capture.lines[0]) self.assertEqual(m.group('status'), '200') def test_post_status_code_201(self): rev = f'log-{uuid.uuid4().hex[:8]}' - self.client.post(PREFIX + '/orders', - json={'llvm_project_revision': rev}, + self.client.post(PREFIX + '/commits', + json={'commit': rev}, headers=admin_headers()) m = COMBINED_RE.match(self.capture.lines[0]) self.assertEqual(m.group('status'), '201') @@ -109,19 +109,19 @@ class TestAccessLogUser(_AccessLogTestCase): """Verify the user field reflects authentication state.""" def test_unauthenticated_request(self): - self.client.get(PREFIX + '/orders') + self.client.get(PREFIX + '/commits') m = COMBINED_RE.match(self.capture.lines[0]) self.assertEqual(m.group('user'), '-') def test_bootstrap_token(self): - self.client.get(PREFIX + '/orders', headers=admin_headers()) + self.client.get(PREFIX + '/commits', headers=admin_headers()) m = COMBINED_RE.match(self.capture.lines[0]) self.assertEqual(m.group('user'), 'bootstrap') def test_named_api_key(self): headers = make_scoped_headers(self.app, 'read') self.capture.clear() # discard log from API key creation - self.client.get(PREFIX + '/orders', headers=headers) + self.client.get(PREFIX + '/commits', headers=headers) m = COMBINED_RE.match(self.capture.lines[0]) self.assertEqual(m.group('user'), 'test-read') @@ -130,7 +130,7 @@ class TestAccessLogMiddleware404(_AccessLogTestCase): """Verify logging for requests that fail at the middleware level.""" def test_nonexistent_testsuite(self): - resp = self.client.get('/api/v5/nonexistent/orders') + resp = self.client.get('/api/v5/nonexistent/commits') self.assertEqual(resp.status_code, 404) self.assertEqual(len(self.capture.lines), 1) m = COMBINED_RE.match(self.capture.lines[0]) @@ -142,25 +142,25 @@ class TestAccessLogHeaders(_AccessLogTestCase): """Verify Referer and User-Agent appear in the log.""" def test_referer_present(self): - self.client.get(PREFIX + '/orders', + self.client.get(PREFIX + '/commits', headers={'Referer': 'http://example.com/page'}) m = COMBINED_RE.match(self.capture.lines[0]) self.assertEqual(m.group('referer'), 'http://example.com/page') def test_referer_absent(self): - self.client.get(PREFIX + '/orders') + self.client.get(PREFIX + '/commits') m = COMBINED_RE.match(self.capture.lines[0]) self.assertEqual(m.group('referer'), '-') def test_user_agent_present(self): - self.client.get(PREFIX + '/orders', + self.client.get(PREFIX + '/commits', headers={'User-Agent': 'TestBot/1.0'}) m = COMBINED_RE.match(self.capture.lines[0]) self.assertEqual(m.group('ua'), 'TestBot/1.0') def test_user_agent_absent(self): # Werkzeug test client sends a default User-Agent; override to empty. - self.client.get(PREFIX + '/orders', + self.client.get(PREFIX + '/commits', headers={'User-Agent': ''}) m = COMBINED_RE.match(self.capture.lines[0]) # Empty string or '-' are both acceptable for absent user agent. @@ -171,7 +171,7 @@ class TestAccessLogContentLength(_AccessLogTestCase): """Verify the size field reflects response content length.""" def test_response_with_body_has_size(self): - self.client.get(PREFIX + '/orders') + self.client.get(PREFIX + '/commits') m = COMBINED_RE.match(self.capture.lines[0]) size = m.group('size') # Should be a positive integer, not '-' diff --git a/tests/server/api/v5/test_auth.py b/tests/server/api/v5/test_auth.py index 08f3219c8..b96e9518b 100644 --- a/tests/server/api/v5/test_auth.py +++ b/tests/server/api/v5/test_auth.py @@ -2,7 +2,7 @@ # # RUN: rm -rf %t.instance %t.pg.log # RUN: %{utils}/with_postgres.sh %t.pg.log \ -# RUN: %{utils}/with_temporary_instance.py %t.instance \ +# RUN: %{utils}/with_temporary_instance.py --db-version 5.0 %t.instance \ # RUN: -- python %s %t.instance # END. diff --git a/tests/server/api/v5/test_errors.py b/tests/server/api/v5/test_errors.py index 427b7e829..58b1032cd 100644 --- a/tests/server/api/v5/test_errors.py +++ b/tests/server/api/v5/test_errors.py @@ -2,7 +2,7 @@ # # RUN: rm -rf %t.instance %t.pg.log # RUN: %{utils}/with_postgres.sh %t.pg.log \ -# RUN: %{utils}/with_temporary_instance.py %t.instance \ +# RUN: %{utils}/with_temporary_instance.py --db-version 5.0 %t.instance \ # RUN: -- python %s %t.instance # END. diff --git a/tests/server/api/v5/test_etag.py b/tests/server/api/v5/test_etag.py index ed14011d6..d0ed65a33 100644 --- a/tests/server/api/v5/test_etag.py +++ b/tests/server/api/v5/test_etag.py @@ -2,7 +2,7 @@ # # RUN: rm -rf %t.instance %t.pg.log # RUN: %{utils}/with_postgres.sh %t.pg.log \ -# RUN: %{utils}/with_temporary_instance.py %t.instance \ +# RUN: %{utils}/with_temporary_instance.py --db-version 5.0 %t.instance \ # RUN: -- python %s %t.instance # END. diff --git a/tests/server/api/v5/test_integration.py b/tests/server/api/v5/test_integration.py index 627427c9c..f38ee5cf5 100644 --- a/tests/server/api/v5/test_integration.py +++ b/tests/server/api/v5/test_integration.py @@ -5,56 +5,34 @@ # # RUN: rm -rf %t.instance %t.pg.log # RUN: %{utils}/with_postgres.sh %t.pg.log \ -# RUN: %{utils}/with_temporary_instance.py %t.instance \ +# RUN: %{utils}/with_temporary_instance.py --db-version 5.0 %t.instance \ # RUN: -- python %s %t.instance # END. -import json import sys import os import unittest import uuid sys.path.insert(0, os.path.dirname(__file__)) -from v5_test_helpers import create_app, create_client, admin_headers +from v5_test_helpers import create_app, create_client, admin_headers, submit_run TS = 'nts' PREFIX = f'/api/v5/{TS}' -def _make_submission_payload(machine_name=None, revision=None, - tests=None): - """Build a valid v2-format JSON submission payload.""" - if machine_name is None: - machine_name = f'integ-machine-{uuid.uuid4().hex[:8]}' - if revision is None: - revision = f'r{uuid.uuid4().hex[:8]}' - if tests is None: - tests = [ - { - 'name': 'test.suite/benchmark1', - 'execution_time': [0.1234, 0.1235], - }, - { - 'name': 'test.suite/benchmark2', - 'compile_time': 13.12, - 'execution_time': 0.2135, - }, - ] - - return json.dumps({ - 'format_version': '2', - 'machine': { - 'name': machine_name, - }, - 'run': { - 'start_time': '2024-06-15T10:00:00', - 'end_time': '2024-06-15T10:30:00', - 'llvm_project_revision': revision, - }, - 'tests': tests, - }) +_DEFAULT_TESTS = [ + { + 'name': 'test.suite/benchmark1', + 'execution_time': [0.1234, 0.1235], + }, + { + 'name': 'test.suite/benchmark2', + 'compile_time': 13.12, + 'execution_time': 0.2135, + }, +] # ----------------------------------------------------------------------- @@ -88,17 +66,8 @@ def setUpClass(cls): cls.client = create_client(cls.app) cls._machine_name = f'submit-wf-{uuid.uuid4().hex[:8]}' cls._revision = f'r{uuid.uuid4().hex[:8]}' - payload = _make_submission_payload( - machine_name=cls._machine_name, - revision=cls._revision, - ) - resp = cls.client.post( - PREFIX + '/runs', - data=payload, - content_type='application/json', - headers=admin_headers(), - ) - data = resp.get_json() + data = submit_run( + cls.client, cls._machine_name, cls._revision, _DEFAULT_TESTS) cls._run_uuid = data.get('run_uuid') def test_01_submission_succeeded(self): @@ -129,13 +98,12 @@ def test_03_run_detail_is_correct(self): "Run detail UUID mismatch") self.assertEqual(data['machine'], self._machine_name, "Run detail machine name mismatch") - self.assertIn('order', data, - "Run detail missing 'order'") + self.assertIn('commit', data, + "Run detail missing 'commit'") self.assertEqual( - data['order'].get('llvm_project_revision'), self._revision, - "Run detail order revision mismatch") - self.assertIn('start_time', data) - self.assertIn('end_time', data) + data['commit'], self._revision, + "Run detail commit mismatch") + self.assertIn('submitted_at', data) def test_04_run_samples_returned(self): """GET /runs/{uuid}/samples returns the submitted samples.""" @@ -227,11 +195,16 @@ def test_api_key_full_lifecycle(self): "New submit key cannot read discovery endpoint") # Step 3: Use the new key to submit a run (within its scope) - payload = _make_submission_payload() + machine = f'key-test-{uuid.uuid4().hex[:8]}' + commit = f'r{uuid.uuid4().hex[:8]}' submit_resp = self.client.post( PREFIX + '/runs', - data=payload, - content_type='application/json', + json={ + 'format_version': '5', + 'machine': {'name': machine}, + 'commit': commit, + 'tests': _DEFAULT_TESTS, + }, headers=key_headers, ) self.assertIn(submit_resp.status_code, [201, 301], @@ -297,15 +270,10 @@ def test_machine_crud_workflow(self): self.assertEqual(create_resp.get_json()['name'], original_name) # Step 2: Submit a run to this machine - payload = _make_submission_payload(machine_name=original_name) - submit_resp = self.client.post( - PREFIX + '/runs', - data=payload, - content_type='application/json', - headers=admin_headers(), - ) - submit_data = submit_resp.get_json() - run_uuid = submit_data.get('run_uuid') + commit = f'r{uuid.uuid4().hex[:8]}' + submit_data = submit_run(self.client, original_name, commit, + _DEFAULT_TESTS) + run_uuid = submit_data['run_uuid'] self.assertIsNotNone(run_uuid, "Run submission did not return a run_uuid") @@ -435,7 +403,7 @@ def test_discovery_nts_suite_has_all_expected_links(self): links = nts_suites[0]['links'] expected_keys = { - 'machines', 'orders', 'runs', 'tests', + 'machines', 'commits', 'runs', 'tests', 'regressions', 'field_changes', 'query', } self.assertEqual(set(links.keys()), expected_keys, @@ -489,11 +457,16 @@ def test_cors_on_run_list(self): def test_cors_on_run_submit(self): """CORS header on POST /runs.""" - payload = _make_submission_payload() + machine = f'cors-m-{uuid.uuid4().hex[:8]}' + commit = f'r{uuid.uuid4().hex[:8]}' resp = self.client.post( PREFIX + '/runs', - data=payload, - content_type='application/json', + json={ + 'format_version': '5', + 'machine': {'name': machine}, + 'commit': commit, + 'tests': _DEFAULT_TESTS, + }, headers=admin_headers(), ) self._assert_cors(resp, 'POST /runs') From 23e8e3406156a50a8a8bba487df0e2cdec3a2b36 Mon Sep 17 00:00:00 2001 From: Louis Dionne Date: Tue, 14 Apr 2026 15:50:58 -0400 Subject: [PATCH 050/143] [DB] Move v5 table creation to `lnt create`, fix concurrent startup crash Gunicorn workers raced on CREATE TABLE during V5DB.__init__, crashing on PostgreSQL's pg_type unique constraint. Fix by moving all DDL to initialize_v5_database(), called once from `lnt create --db-version 5.0`. - Move APIKey model from auth.py onto _global_base in models.py so create_global_tables() creates all three global tables together - Add idempotent initialize_v5_database() for one-time DB setup - Make V5DB.__init__ read-only (no DDL), with clear error if DB not initialized - Remove _ensure_schema_version_row (moved into initialize_v5_database) - Remove create_all from _load_schemas_from_db (suite tables are created by create_suite at registration time) - Pass --db-version through to `lnt create` in test harness Co-Authored-By: Claude Opus 4.6 (1M context) --- lnt/lnttool/create.py | 6 ++- lnt/server/api/v5/auth.py | 25 +---------- lnt/server/db/v5/__init__.py | 60 +++++++++++++++++--------- lnt/server/db/v5/models.py | 17 +++++++- tests/server/db/v5/test_models.py | 60 ++++++++++++++++++++++++-- tests/utils/with_temporary_instance.py | 29 +++---------- 6 files changed, 125 insertions(+), 72 deletions(-) diff --git a/lnt/lnttool/create.py b/lnt/lnttool/create.py index 84ad1f0b5..eeb576a30 100644 --- a/lnt/lnttool/create.py +++ b/lnt/lnttool/create.py @@ -167,7 +167,11 @@ def action_create(instance_path, name, config, wsgi, tmp_dir, db_dir, os.chmod(wsgi_path, 0o755) # Execute an upgrade on the database to initialize the schema. - lnt.server.db.migrate.update_path(db_path) + if db_version == '5.0': + from lnt.server.db.v5 import initialize_v5_database + initialize_v5_database(db_path) + else: + lnt.server.db.migrate.update_path(db_path) print('created LNT configuration in %r' % basepath) print(' configuration file: %s' % cfg_path) diff --git a/lnt/server/api/v5/auth.py b/lnt/server/api/v5/auth.py index 2a955d411..ee1cbd866 100644 --- a/lnt/server/api/v5/auth.py +++ b/lnt/server/api/v5/auth.py @@ -1,5 +1,4 @@ -"""v5 API authentication: APIKey model, Bearer token validation, scope -decorators. +"""v5 API authentication: Bearer token validation and scope decorators. Scope hierarchy (linear, each level includes all below): read (0) < submit (1) < triage (2) < manage (3) < admin (4) @@ -11,29 +10,9 @@ import functools from flask import current_app, g, request -from sqlalchemy import Column, String, Integer, Boolean, DateTime -from sqlalchemy.ext.declarative import declarative_base import sqlalchemy.exc -# Separate declarative base so the APIKey table does not contaminate -# per-testsuite metadata. -APIKeyBase = declarative_base() - - -class APIKey(APIKeyBase): - """API key stored in the global (non-per-testsuite) database.""" - - __tablename__ = 'APIKey' - - id = Column("ID", Integer, primary_key=True) - name = Column("Name", String(256), nullable=False) - key_prefix = Column("KeyPrefix", String(8), nullable=False) - key_hash = Column("KeyHash", String(64), nullable=False, unique=True, - index=True) - scope = Column("Scope", String(32), nullable=False) - created_at = Column("CreatedAt", DateTime, nullable=False) - last_used_at = Column("LastUsedAt", DateTime, nullable=True) - is_active = Column("IsActive", Boolean, nullable=False, default=True) +from lnt.server.db.v5.models import APIKey # --------------------------------------------------------------------------- diff --git a/lnt/server/db/v5/__init__.py b/lnt/server/db/v5/__init__.py index 6bf32d1ae..d44097b8e 100644 --- a/lnt/server/db/v5/__init__.py +++ b/lnt/server/db/v5/__init__.py @@ -52,6 +52,31 @@ def _escape_like(s: str) -> str: return s.replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_") +def initialize_v5_database(path: str) -> None: + """Create v5 global tables and seed rows. + + Idempotent -- safe to call on an already-initialized database. + Called by ``lnt create --db-version 5.0``. + """ + engine = sqlalchemy.create_engine(path) + try: + create_global_tables(engine) + session = sqlalchemy.orm.sessionmaker(engine)() + try: + if session.query(V5SchemaVersion).get(1) is None: + session.add(V5SchemaVersion(id=1, version=0)) + session.commit() + except sqlalchemy.exc.IntegrityError: + session.rollback() + except Exception: + session.rollback() + raise + finally: + session.close() + finally: + engine.dispose() + + class V5DB: """Top-level database handle for a v5 LNT instance. @@ -74,9 +99,19 @@ def __init__(self, path: str, config: Any): self.testsuite: dict[str, V5TestSuiteDB] = {} self._schema_version: int | None = None - create_global_tables(self.engine) - self._ensure_schema_version_row() - self._load_schemas_from_db() + try: + self._load_schemas_from_db() + except sqlalchemy.exc.ProgrammingError as e: + self.engine.dispose() + if "v5_schema" in str(e): + raise RuntimeError( + "v5 database not initialized. " + "Run: lnt create --db-version 5.0" + ) from e + raise + except Exception: + self.engine.dispose() + raise # -- schema storage -------------------------------------------------------- @@ -114,24 +149,8 @@ def _schema_to_dict(schema: TestSuiteSchema) -> dict[str, Any]: ], } - def _ensure_schema_version_row(self) -> None: - """Make sure the v5_schema_version table has its single row.""" - session = self.sessionmaker() - try: - row = session.query(V5SchemaVersion).get(1) - if row is None: - row = V5SchemaVersion(id=1, version=0) - session.add(row) - session.commit() - except Exception: - session.rollback() - raise - finally: - session.close() - def _load_schemas_from_db(self) -> None: - """Read all rows from ``v5_schema``, parse each into a - TestSuiteSchema, build models, and create per-suite tables.""" + """Read all rows from ``v5_schema``, parse each, and build models.""" session = self.sessionmaker() try: rows = session.query(V5Schema).all() @@ -143,7 +162,6 @@ def _load_schemas_from_db(self) -> None: data = json.loads(row.schema_json) schema = parse_schema(data) models = create_suite_models(schema) - models.base.metadata.create_all(self.engine) tsdb = V5TestSuiteDB(self, schema, models) self.testsuite[schema.name] = tsdb finally: diff --git a/lnt/server/db/v5/models.py b/lnt/server/db/v5/models.py index 8017a2281..ae8da3974 100644 --- a/lnt/server/db/v5/models.py +++ b/lnt/server/db/v5/models.py @@ -16,6 +16,7 @@ import sqlalchemy import sqlalchemy.ext.declarative from sqlalchemy import ( + Boolean, Column, DateTime, Float, @@ -54,8 +55,22 @@ class V5SchemaVersion(_global_base): # type: ignore[misc] version = Column("version", Integer, nullable=False) +class APIKey(_global_base): # type: ignore[misc] + """API key for v5 REST API authentication.""" + __tablename__ = "APIKey" + id = Column("ID", Integer, primary_key=True) + name = Column("Name", String(256), nullable=False) + key_prefix = Column("KeyPrefix", String(8), nullable=False) + key_hash = Column("KeyHash", String(64), nullable=False, unique=True, + index=True) + scope = Column("Scope", String(32), nullable=False) + created_at = Column("CreatedAt", DateTime, nullable=False) + last_used_at = Column("LastUsedAt", DateTime, nullable=True) + is_active = Column("IsActive", Boolean, nullable=False, default=True) + + def create_global_tables(engine) -> None: - """Create the global ``v5_schema`` and ``v5_schema_version`` tables.""" + """Create the global v5 tables (schema, schema_version, APIKey).""" _global_base.metadata.create_all(engine) diff --git a/tests/server/db/v5/test_models.py b/tests/server/db/v5/test_models.py index 5b127d480..acbfe9ea9 100644 --- a/tests/server/db/v5/test_models.py +++ b/tests/server/db/v5/test_models.py @@ -12,17 +12,22 @@ import sqlalchemy.exc from lnt.server.db.v5.schema import parse_schema -from lnt.server.db.v5.models import create_suite_models +from lnt.server.db.v5.models import _global_base, create_suite_models +from lnt.server.db.v5 import V5DB, initialize_v5_database -def _make_engine(): +def _db_path(): db_uri = os.environ.get('LNT_TEST_DB_URI') db_name = os.environ.get('LNT_TEST_DB_NAME') if not db_uri or not db_name: raise unittest.SkipTest( "LNT_TEST_DB_URI / LNT_TEST_DB_NAME not set " "(run via with_postgres.sh)") - return sqlalchemy.create_engine(f"{db_uri}/{db_name}") + return f"{db_uri}/{db_name}" + + +def _make_engine(): + return sqlalchemy.create_engine(_db_path()) def _test_schema(): @@ -622,5 +627,54 @@ def test_delete_machine_cascades_to_runs(self): session.close() +class TestInitializeV5Database(unittest.TestCase): + """Tests for initialize_v5_database and V5DB read-only init.""" + + @classmethod + def setUpClass(cls): + cls.engine = _make_engine() + + @classmethod + def tearDownClass(cls): + _global_base.metadata.drop_all(cls.engine) + cls.engine.dispose() + + def setUp(self): + _global_base.metadata.drop_all(self.engine) + + def test_initialize_v5_database_idempotent(self): + """Calling initialize_v5_database twice should not raise.""" + initialize_v5_database(_db_path()) + initialize_v5_database(_db_path()) + + insp = sqlalchemy.inspect(self.engine) + tables = insp.get_table_names() + self.assertIn("v5_schema", tables) + self.assertIn("v5_schema_version", tables) + self.assertIn("APIKey", tables) + + def test_v5db_init_on_initialized_database(self): + """V5DB.__init__ should succeed read-only on an initialized DB.""" + initialize_v5_database(_db_path()) + + class _FakeConfig: + schemasDir = "/nonexistent" + + db = V5DB(_db_path(), _FakeConfig()) + self.assertEqual(db.testsuite, {}) + self.assertEqual(db._schema_version, 0) + db.engine.dispose() + + def test_v5db_init_without_initialization_gives_clear_error(self): + """V5DB.__init__ on an uninitialized DB should raise RuntimeError.""" + + class _FakeConfig: + schemasDir = "/nonexistent" + + with self.assertRaises(RuntimeError) as ctx: + V5DB(_db_path(), _FakeConfig()) + self.assertIn("not initialized", str(ctx.exception)) + + if __name__ == '__main__': unittest.main(argv=[sys.argv[0]], exit=True) diff --git a/tests/utils/with_temporary_instance.py b/tests/utils/with_temporary_instance.py index 148c22fa9..a7b42676a 100755 --- a/tests/utils/with_temporary_instance.py +++ b/tests/utils/with_temporary_instance.py @@ -15,31 +15,13 @@ def _setup_v5_instance(dest_dir): - """Patch a freshly-created LNT instance for v5 and create a test suite. + """Create a test suite in a freshly-created v5 LNT instance. - After ``lnt create`` has built the directory structure and lnt.cfg, - this function: - 1. Patches lnt.cfg to set ``db_version: '5.0'`` on the default database. - 2. Boots the app (which creates V5DB global tables). - 3. Creates an NTS-equivalent test suite in the v5 schema. + After ``lnt create --db-version 5.0`` has built the directory structure, + config, and v5 global tables, this function: + 1. Boots the app (reads existing v5 schema). + 2. Creates an NTS-equivalent test suite. """ - import re - - cfg_path = os.path.join(dest_dir, 'lnt.cfg') - with open(cfg_path) as f: - cfg_text = f.read() - - # Insert db_version into the default database entry. The template - # emits: 'default' : { 'path' : '...' } - cfg_text = re.sub( - r"('default'\s*:\s*\{)\s*'path'", - r"\1 'db_version': '5.0', 'path'", - cfg_text, - ) - with open(cfg_path, 'w') as f: - f.write(cfg_text) - - # Boot the app -- Config reads db_version and instantiates V5DB. import lnt.server.ui.app app = lnt.server.ui.app.App.create_standalone(dest_dir) @@ -126,6 +108,7 @@ def main(): '--default-db', db_name, '--api-auth-token', 'test_token', '--url', 'http://localhost/perf', + '--db-version', args.db_version, ]) # 2. Symlink schema YAML files into the instance. From 934da19be2d2b0fec736172a9a6f4b92996e90b6 Mon Sep 17 00:00:00 2001 From: Louis Dionne Date: Tue, 14 Apr 2026 14:24:45 -0400 Subject: [PATCH 051/143] [UI] Rebase foundation types and API client from Order to Commit Update shared frontend modules (types, API client, utilities, state, router) to match the v5 REST API's Commit model. Order types become Commit types, runs carry a plain commit string instead of an order dict, and URL params change from order_a/order_b to commit_a/commit_b. Co-Authored-By: Claude Opus 4.6 (1M context) --- .../ui/v5/frontend/src/__tests__/api.test.ts | 206 +++++++++--------- .../v5/frontend/src/__tests__/state.test.ts | 94 ++++---- .../v5/frontend/src/__tests__/utils.test.ts | 16 +- lnt/server/ui/v5/frontend/src/api.ts | 69 +++--- lnt/server/ui/v5/frontend/src/main.ts | 2 +- lnt/server/ui/v5/frontend/src/state.ts | 12 +- lnt/server/ui/v5/frontend/src/types.ts | 54 ++--- lnt/server/ui/v5/frontend/src/utils.ts | 4 - 8 files changed, 218 insertions(+), 239 deletions(-) diff --git a/lnt/server/ui/v5/frontend/src/__tests__/api.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/api.test.ts index 164e40ea0..c77722a29 100644 --- a/lnt/server/ui/v5/frontend/src/__tests__/api.test.ts +++ b/lnt/server/ui/v5/frontend/src/__tests__/api.test.ts @@ -1,12 +1,12 @@ import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; -import { setApiBase, getFields, getOrders, getMachines, getRuns, getSamples, - getMachine, getMachineRuns, deleteMachine, getRun, deleteRun, getOrder, getRunsByOrder, - getFieldChanges, searchOrdersByTag, updateOrderTag, fetchTrends, +import { setApiBase, getFields, getCommits, getMachines, getRuns, getSamples, + getMachine, getMachineRuns, deleteMachine, getRun, deleteRun, getCommit, getRunsByCommit, + getFieldChanges, searchCommits, updateCommit, fetchTrends, fetchOneCursorPage, apiUrl, ApiError, authErrorMessage, } from '../api'; import type { CursorPaginated, FieldInfo, MachineInfo, MachineRunInfo, OffsetPaginated, - OrderSummary, OrderDetail, RunInfo, RunDetail, SampleInfo, FieldChangeInfo, + CommitSummary, CommitDetail, RunInfo, RunDetail, SampleInfo, FieldChangeInfo, QueryDataPoint, } from '../types'; @@ -225,10 +225,10 @@ describe('AbortSignal support', () => { it('passes signal to every fetch call in paginated requests', async () => { const controller = new AbortController(); mockFetch - .mockResolvedValueOnce(mockResponse(cursorPage([{ fields: { llvm_project_revision: '100' } }], 'cursor1'))) - .mockResolvedValueOnce(mockResponse(cursorPage([{ fields: { llvm_project_revision: '200' } }]))); + .mockResolvedValueOnce(mockResponse(cursorPage([{ commit: '100', ordinal: 1, fields: {} }], 'cursor1'))) + .mockResolvedValueOnce(mockResponse(cursorPage([{ commit: '200', ordinal: 2, fields: {} }]))); - await getOrders('nts', controller.signal); + await getCommits('nts', controller.signal); expect(mockFetch.mock.calls).toHaveLength(2); expect(mockFetch.mock.calls[0][1].signal).toBe(controller.signal); @@ -242,37 +242,37 @@ describe('AbortSignal support', () => { describe('cursor-based pagination', () => { it('fetches a single page when cursor.next is null', async () => { - const order: OrderSummary = { fields: { llvm_project_revision: '100' } }; - mockFetch.mockResolvedValueOnce(mockResponse(cursorPage([order]))); + const commit: CommitSummary = { commit: '100', ordinal: 1, fields: {} }; + mockFetch.mockResolvedValueOnce(mockResponse(cursorPage([commit]))); - const result = await getOrders('nts'); + const result = await getCommits('nts'); - expect(result).toEqual([order]); + expect(result).toEqual([commit]); expect(mockFetch).toHaveBeenCalledTimes(1); }); it('fetches multiple pages and concatenates results', async () => { - const o1: OrderSummary = { fields: { llvm_project_revision: '100' } }; - const o2: OrderSummary = { fields: { llvm_project_revision: '200' } }; - const o3: OrderSummary = { fields: { llvm_project_revision: '300' } }; + const c1: CommitSummary = { commit: '100', ordinal: 1, fields: {} }; + const c2: CommitSummary = { commit: '200', ordinal: 2, fields: {} }; + const c3: CommitSummary = { commit: '300', ordinal: 3, fields: {} }; mockFetch - .mockResolvedValueOnce(mockResponse(cursorPage([o1], 'cursor-abc'))) - .mockResolvedValueOnce(mockResponse(cursorPage([o2], 'cursor-def'))) - .mockResolvedValueOnce(mockResponse(cursorPage([o3]))); + .mockResolvedValueOnce(mockResponse(cursorPage([c1], 'cursor-abc'))) + .mockResolvedValueOnce(mockResponse(cursorPage([c2], 'cursor-def'))) + .mockResolvedValueOnce(mockResponse(cursorPage([c3]))); - const result = await getOrders('nts'); + const result = await getCommits('nts'); - expect(result).toEqual([o1, o2, o3]); + expect(result).toEqual([c1, c2, c3]); expect(mockFetch).toHaveBeenCalledTimes(3); }); it('passes cursor parameter on subsequent pages', async () => { mockFetch - .mockResolvedValueOnce(mockResponse(cursorPage([{ fields: { rev: '1' } }], 'next-page-cursor'))) - .mockResolvedValueOnce(mockResponse(cursorPage([{ fields: { rev: '2' } }]))); + .mockResolvedValueOnce(mockResponse(cursorPage([{ commit: '1', ordinal: 1, fields: {} }], 'next-page-cursor'))) + .mockResolvedValueOnce(mockResponse(cursorPage([{ commit: '2', ordinal: 2, fields: {} }]))); - await getOrders('nts'); + await getCommits('nts'); // First call should have no cursor const firstUrl = new URL(mockFetch.mock.calls[0][0]); @@ -287,11 +287,11 @@ describe('cursor-based pagination', () => { it('calls onProgress callback with running total after each page', async () => { mockFetch - .mockResolvedValueOnce(mockResponse(cursorPage([{ fields: { rev: '1' } }, { fields: { rev: '2' } }], 'c1'))) - .mockResolvedValueOnce(mockResponse(cursorPage([{ fields: { rev: '3' } }]))); + .mockResolvedValueOnce(mockResponse(cursorPage([{ commit: '1', ordinal: 1, fields: {} }, { commit: '2', ordinal: 2, fields: {} }], 'c1'))) + .mockResolvedValueOnce(mockResponse(cursorPage([{ commit: '3', ordinal: 3, fields: {} }]))); const onProgress = vi.fn(); - await getOrders('nts', undefined, onProgress); + await getCommits('nts', undefined, onProgress); expect(onProgress).toHaveBeenCalledTimes(2); expect(onProgress).toHaveBeenNthCalledWith(1, 2); @@ -300,10 +300,10 @@ describe('cursor-based pagination', () => { it('stops paginating when error occurs mid-pagination', async () => { mockFetch - .mockResolvedValueOnce(mockResponse(cursorPage([{ fields: { rev: '1' } }], 'c1'))) + .mockResolvedValueOnce(mockResponse(cursorPage([{ commit: '1', ordinal: 1, fields: {} }], 'c1'))) .mockResolvedValueOnce(mockResponse('server error', 500, 'Internal Server Error')); - await expect(getOrders('nts')).rejects.toThrow('API 500'); + await expect(getCommits('nts')).rejects.toThrow('API 500'); expect(mockFetch).toHaveBeenCalledTimes(2); }); }); @@ -345,29 +345,29 @@ describe('getFields', () => { }); // =========================================================================== -// getOrders +// getCommits // =========================================================================== -describe('getOrders', () => { - it('returns all orders across multiple pages', async () => { - const o1: OrderSummary = { fields: { llvm_project_revision: '100' } }; - const o2: OrderSummary = { fields: { llvm_project_revision: '200' } }; +describe('getCommits', () => { + it('returns all commits across multiple pages', async () => { + const c1: CommitSummary = { commit: '100', ordinal: 1, fields: {} }; + const c2: CommitSummary = { commit: '200', ordinal: 2, fields: {} }; mockFetch - .mockResolvedValueOnce(mockResponse(cursorPage([o1], 'c1'))) - .mockResolvedValueOnce(mockResponse(cursorPage([o2]))); + .mockResolvedValueOnce(mockResponse(cursorPage([c1], 'c1'))) + .mockResolvedValueOnce(mockResponse(cursorPage([c2]))); - const result = await getOrders('nts'); - expect(result).toEqual([o1, o2]); + const result = await getCommits('nts'); + expect(result).toEqual([c1, c2]); }); it('constructs the correct URL with limit=500', async () => { mockFetch.mockResolvedValueOnce(mockResponse(cursorPage([]))); - await getOrders('nts'); + await getCommits('nts'); const url = new URL(mockFetch.mock.calls[0][0]); - expect(url.pathname).toBe('/api/v5/nts/orders'); + expect(url.pathname).toBe('/api/v5/nts/commits'); expect(url.searchParams.get('limit')).toBe('500'); }); }); @@ -455,16 +455,16 @@ describe('getRuns', () => { const r1: RunInfo = { uuid: 'aaa-111', machine: 'machine-1', - order: { llvm_project_revision: '100' }, - start_time: '2025-01-01T00:00:00', - end_time: '2025-01-01T01:00:00', + commit: '100', + submitted_at: '2025-01-01T00:00:00', + run_parameters: {}, }; const r2: RunInfo = { uuid: 'bbb-222', machine: 'machine-1', - order: { llvm_project_revision: '200' }, - start_time: null, - end_time: null, + commit: '200', + submitted_at: null, + run_parameters: {}, }; mockFetch @@ -475,24 +475,24 @@ describe('getRuns', () => { expect(result).toEqual([r1, r2]); }); - it('passes machine and order as query params', async () => { + it('passes machine and commit as query params', async () => { mockFetch.mockResolvedValueOnce(mockResponse(cursorPage([]))); - await getRuns('nts', { machine: 'machine-1', order: 'rev100' }); + await getRuns('nts', { machine: 'machine-1', commit: 'rev100' }); const url = new URL(mockFetch.mock.calls[0][0]); expect(url.searchParams.get('machine')).toBe('machine-1'); - expect(url.searchParams.get('order')).toBe('rev100'); + expect(url.searchParams.get('commit')).toBe('rev100'); expect(url.searchParams.get('limit')).toBe('500'); }); - it('omits order when not provided', async () => { + it('omits commit when not provided', async () => { mockFetch.mockResolvedValueOnce(mockResponse(cursorPage([]))); await getRuns('nts', { machine: 'machine-1' }); const url = new URL(mockFetch.mock.calls[0][0]); - expect(url.searchParams.has('order')).toBe(false); + expect(url.searchParams.has('commit')).toBe(false); }); it('constructs the correct URL path', async () => { @@ -582,8 +582,8 @@ describe('URL construction', () => { expect(new URL(mockFetch.mock.calls[0][0]).pathname).toBe('/myapp/api/v5/test-suites/nts'); mockFetch.mockResolvedValueOnce(mockResponse(cursorPage([]))); - await getOrders('nts'); - expect(new URL(mockFetch.mock.calls[1][0]).pathname).toBe('/myapp/api/v5/nts/orders'); + await getCommits('nts'); + expect(new URL(mockFetch.mock.calls[1][0]).pathname).toBe('/myapp/api/v5/nts/commits'); mockFetch.mockResolvedValueOnce(mockResponse(offsetPage([], 0))); await getMachines('nts', {}); @@ -605,16 +605,16 @@ describe('URL construction', () => { describe('query parameter handling', () => { it('omits empty string params', async () => { - // getRuns with empty order should not include it + // getRuns with empty commit should not include it mockFetch.mockResolvedValueOnce(mockResponse(cursorPage([]))); - await getRuns('nts', { machine: 'machine-1', order: '' }); + await getRuns('nts', { machine: 'machine-1', commit: '' }); const url = new URL(mockFetch.mock.calls[0][0]); expect(url.searchParams.get('machine')).toBe('machine-1'); - // order is '' and should be excluded by the fetchJson params filtering - // (but actually getRuns conditionally adds order, so let's test via getMachines) - expect(url.searchParams.has('order')).toBe(false); + // commit is '' and should be excluded by the fetchJson params filtering + // (but actually getRuns conditionally adds commit, so let's test via getMachines) + expect(url.searchParams.has('commit')).toBe(false); }); }); @@ -645,18 +645,18 @@ describe('getMachine', () => { describe('getMachineRuns', () => { it('fetches runs for a machine with sort and limit', async () => { const page = cursorPage( - [{ uuid: 'r1', order: { rev: '100' }, start_time: null, end_time: null }], + [{ uuid: 'r1', commit: '100', submitted_at: null }], 'cursor-2', ); mockFetch.mockResolvedValueOnce(mockResponse(page)); - const result = await getMachineRuns('nts', 'clang-x86', { sort: '-start_time', limit: 10 }); + const result = await getMachineRuns('nts', 'clang-x86', { sort: '-submitted_at', limit: 10 }); expect(result.items).toHaveLength(1); expect(result.cursor.next).toBe('cursor-2'); const url = new URL(mockFetch.mock.calls[0][0]); expect(url.pathname).toBe('/api/v5/nts/machines/clang-x86/runs'); - expect(url.searchParams.get('sort')).toBe('-start_time'); + expect(url.searchParams.get('sort')).toBe('-submitted_at'); expect(url.searchParams.get('limit')).toBe('10'); }); @@ -734,8 +734,8 @@ describe('ApiError and authErrorMessage', () => { describe('getRun', () => { it('fetches a single run by UUID', async () => { const run: RunDetail = { - uuid: 'abc-123', machine: 'm1', order: { rev: '100' }, - start_time: '2025-01-01T00:00:00', end_time: null, parameters: {}, + uuid: 'abc-123', machine: 'm1', commit: '100', + submitted_at: '2025-01-01T00:00:00', parameters: {}, }; mockFetch.mockResolvedValueOnce(mockResponse(run)); @@ -772,39 +772,37 @@ describe('deleteRun', () => { }); }); -describe('getOrder', () => { - it('fetches order detail with prev/next and tag', async () => { - const order: OrderDetail = { - fields: { rev: '100' }, - tag: 'release-18', - previous_order: { fields: { rev: '99' }, link: '/api/v5/nts/orders/99' }, - next_order: null, +describe('getCommit', () => { + it('fetches commit detail with prev/next', async () => { + const commit: CommitDetail = { + commit: '100', ordinal: 1, fields: {}, + previous_commit: { commit: '99', ordinal: 0, link: '/api/v5/nts/commits/99' }, + next_commit: null, }; - mockFetch.mockResolvedValueOnce(mockResponse(order)); + mockFetch.mockResolvedValueOnce(mockResponse(commit)); - const result = await getOrder('nts', '100'); + const result = await getCommit('nts', '100'); - expect(result.tag).toBe('release-18'); - expect(result.previous_order).not.toBeNull(); - expect(result.next_order).toBeNull(); + expect(result.previous_commit).not.toBeNull(); + expect(result.next_commit).toBeNull(); const url = new URL(mockFetch.mock.calls[0][0]); - expect(url.pathname).toBe('/api/v5/nts/orders/100'); + expect(url.pathname).toBe('/api/v5/nts/commits/100'); }); }); -describe('getRunsByOrder', () => { - it('auto-paginates runs filtered by order value', async () => { +describe('getRunsByCommit', () => { + it('auto-paginates runs filtered by commit value', async () => { const run: RunInfo = { - uuid: 'r1', machine: 'm1', order: { rev: '100' }, - start_time: null, end_time: null, + uuid: 'r1', machine: 'm1', commit: '100', + submitted_at: null, run_parameters: {}, }; mockFetch.mockResolvedValueOnce(mockResponse(cursorPage([run]))); - const result = await getRunsByOrder('nts', '100'); + const result = await getRunsByCommit('nts', '100'); expect(result).toHaveLength(1); const url = new URL(mockFetch.mock.calls[0][0]); - expect(url.searchParams.get('order')).toBe('100'); + expect(url.searchParams.get('commit')).toBe('100'); }); }); @@ -812,8 +810,7 @@ describe('getFieldChanges', () => { it('fetches field changes with limit', async () => { const fc: FieldChangeInfo = { uuid: 'fc1', test: 't1', machine: 'm1', metric: 'compile_time', - old_value: 1.0, new_value: 2.0, start_order: '99', end_order: '100', - run_uuid: null, + old_value: 1.0, new_value: 2.0, start_commit: '99', end_commit: '100', }; mockFetch.mockResolvedValueOnce(mockResponse(cursorPage([fc]))); @@ -826,35 +823,34 @@ describe('getFieldChanges', () => { }); }); -describe('searchOrdersByTag', () => { - it('passes tag_prefix and limit params', async () => { - const order: OrderSummary = { fields: { rev: '100' }, tag: 'release-18' }; - mockFetch.mockResolvedValueOnce(mockResponse(cursorPage([order]))); +describe('searchCommits', () => { + it('passes search and limit params', async () => { + const commit: CommitSummary = { commit: '100', ordinal: 1, fields: {} }; + mockFetch.mockResolvedValueOnce(mockResponse(cursorPage([commit]))); - const result = await searchOrdersByTag('nts', 'release', { limit: 10 }); + const result = await searchCommits('nts', 'release', { limit: 10 }); expect(result.items).toHaveLength(1); - expect(result.items[0].tag).toBe('release-18'); const url = new URL(mockFetch.mock.calls[0][0]); - expect(url.pathname).toBe('/api/v5/nts/orders'); - expect(url.searchParams.get('tag_prefix')).toBe('release'); + expect(url.pathname).toBe('/api/v5/nts/commits'); + expect(url.searchParams.get('search')).toBe('release'); expect(url.searchParams.get('limit')).toBe('10'); }); }); -describe('updateOrderTag', () => { - it('sends PATCH with tag in JSON body', async () => { - const order: OrderDetail = { - fields: { rev: '100' }, tag: 'new-tag', - previous_order: null, next_order: null, +describe('updateCommit', () => { + it('sends PATCH with updates in JSON body', async () => { + const commit: CommitDetail = { + commit: '100', ordinal: 1, fields: {}, + previous_commit: null, next_commit: null, }; - mockFetch.mockResolvedValueOnce(mockResponse(order)); + mockFetch.mockResolvedValueOnce(mockResponse(commit)); - const result = await updateOrderTag('nts', '100', 'new-tag'); + const result = await updateCommit('nts', '100', { tag: 'new-tag' }); - expect(result.tag).toBe('new-tag'); + expect(result.commit).toBe('100'); const [url, opts] = mockFetch.mock.calls[0]; - expect(new URL(url).pathname).toBe('/api/v5/nts/orders/100'); + expect(new URL(url).pathname).toBe('/api/v5/nts/commits/100'); expect(opts.method).toBe('PATCH'); expect(JSON.parse(opts.body)).toEqual({ tag: 'new-tag' }); expect(opts.headers['Content-Type']).toBe('application/json'); @@ -863,10 +859,10 @@ describe('updateOrderTag', () => { it('includes auth token when set', async () => { storedToken = 'my-admin-token'; mockFetch.mockResolvedValueOnce(mockResponse({ - fields: { rev: '100' }, tag: null, previous_order: null, next_order: null, + commit: '100', ordinal: 1, fields: {}, previous_commit: null, next_commit: null, })); - await updateOrderTag('nts', '100', null); + await updateCommit('nts', '100', { tag: null }); const [, opts] = mockFetch.mock.calls[0]; expect(opts.headers['Authorization']).toBe('Bearer my-admin-token'); @@ -875,7 +871,7 @@ describe('updateOrderTag', () => { it('throws on non-ok response', async () => { mockFetch.mockResolvedValueOnce(mockResponse('Forbidden', 403, 'Forbidden')); - await expect(updateOrderTag('nts', '100', 'x')).rejects.toThrow('API 403'); + await expect(updateCommit('nts', '100', { tag: 'x' })).rejects.toThrow('API 403'); }); }); @@ -897,7 +893,7 @@ describe('apiUrl', () => { it('encodes special characters in test suite name', () => { setApiBase(''); - expect(apiUrl('my suite', 'orders')).toBe('/api/v5/my%20suite/orders'); + expect(apiUrl('my suite', 'commits')).toBe('/api/v5/my%20suite/commits'); }); }); @@ -909,7 +905,7 @@ describe('fetchOneCursorPage', () => { it('returns items and nextCursor from a single page', async () => { const pt: QueryDataPoint = { test: 't1', machine: 'm1', metric: 'exec_time', value: 1.0, - order: { rev: '100' }, run_uuid: 'r1', timestamp: null, + commit: '100', ordinal: 1, run_uuid: 'r1', submitted_at: null, }; mockFetch.mockResolvedValueOnce(mockResponse(cursorPage([pt], 'next-abc'))); @@ -962,7 +958,7 @@ describe('fetchTrends', () => { it('sends POST with JSON body containing metric and machine list', async () => { mockFetch.mockResolvedValueOnce(mockResponse({ metric: 'exec_time', - items: [{ machine: 'm1', order: { rev: '100' }, timestamp: '2025-01-01T00:00:00Z', value: 42.0 }], + items: [{ machine: 'm1', commit: '100', ordinal: 1, submitted_at: '2025-01-01T00:00:00Z', value: 42.0 }], })); const result = await fetchTrends('nts', { metric: 'exec_time', machine: ['m1', 'm2'], afterTime: '2025-01-01T00:00:00Z' }); diff --git a/lnt/server/ui/v5/frontend/src/__tests__/state.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/state.test.ts index db9005c2a..c471065b0 100644 --- a/lnt/server/ui/v5/frontend/src/__tests__/state.test.ts +++ b/lnt/server/ui/v5/frontend/src/__tests__/state.test.ts @@ -5,8 +5,8 @@ import type { AppState } from '../types'; function makeDefaults(): AppState { return { - sideA: { suite: '', order: '', machine: '', runs: [], runAgg: 'median' }, - sideB: { suite: '', order: '', machine: '', runs: [], runAgg: 'median' }, + sideA: { suite: '', commit: '', machine: '', runs: [], runAgg: 'median' }, + sideB: { suite: '', commit: '', machine: '', runs: [], runAgg: 'median' }, metric: '', sampleAgg: 'median', noise: 1, @@ -24,10 +24,10 @@ describe('encodeToUrl', () => { it('includes non-default values', () => { const state = makeDefaults(); - state.sideA.order = 'rev123'; + state.sideA.commit = 'rev123'; state.sideA.machine = 'machine-a'; state.sideA.runs = ['uuid-1']; - state.sideB.order = 'rev456'; + state.sideB.commit = 'rev456'; state.sideB.machine = 'machine-b'; state.sideB.runs = ['uuid-2', 'uuid-3']; state.sideB.runAgg = 'mean'; @@ -42,10 +42,10 @@ describe('encodeToUrl', () => { const qs = encodeToUrl(state); const params = new URLSearchParams(qs); - expect(params.get('order_a')).toBe('rev123'); + expect(params.get('commit_a')).toBe('rev123'); expect(params.get('machine_a')).toBe('machine-a'); expect(params.get('runs_a')).toBe('uuid-1'); - expect(params.get('order_b')).toBe('rev456'); + expect(params.get('commit_b')).toBe('rev456'); expect(params.get('machine_b')).toBe('machine-b'); expect(params.get('runs_b')).toBe('uuid-2,uuid-3'); expect(params.get('run_agg_b')).toBe('mean'); @@ -60,7 +60,7 @@ describe('encodeToUrl', () => { it('omits default runAgg (median)', () => { const state = makeDefaults(); - state.sideA.order = 'rev'; + state.sideA.commit = 'rev'; state.sideA.runAgg = 'median'; const params = new URLSearchParams(encodeToUrl(state)); expect(params.has('run_agg_a')).toBe(false); @@ -89,8 +89,8 @@ describe('decodeFromUrl', () => { }); it('decodes side A parameters', () => { - const result = decodeFromUrl('?order_a=rev123&machine_a=machine-a&runs_a=uuid-1'); - expect(result.sideA?.order).toBe('rev123'); + const result = decodeFromUrl('?commit_a=rev123&machine_a=machine-a&runs_a=uuid-1'); + expect(result.sideA?.commit).toBe('rev123'); expect(result.sideA?.machine).toBe('machine-a'); expect(result.sideA?.runs).toEqual(['uuid-1']); }); @@ -104,7 +104,7 @@ describe('decodeFromUrl', () => { const result = decodeFromUrl('?sample_agg=bogus&run_agg_a=invalid'); expect(result.sampleAgg).toBeUndefined(); // sideA should not be set since only run_agg_a was provided with invalid value - // But order_a/machine_a/runs_a are all absent, so runAggA is undefined, + // But commit_a/machine_a/runs_a are all absent, so runAggA is undefined, // and nothing triggers sideA creation expect(result.sideA).toBeUndefined(); }); @@ -149,8 +149,8 @@ describe('decodeFromUrl', () => { describe('round-trip', () => { it('encode then decode preserves full non-default state', () => { const state = makeDefaults(); - state.sideA = { suite: 'nts', order: 'rev1', machine: 'mach-a', runs: ['u1', 'u2'], runAgg: 'mean' }; - state.sideB = { suite: 'compile', order: 'rev2', machine: 'mach-b', runs: ['u3'], runAgg: 'max' }; + state.sideA = { suite: 'nts', commit: 'rev1', machine: 'mach-a', runs: ['u1', 'u2'], runAgg: 'mean' }; + state.sideB = { suite: 'compile', commit: 'rev2', machine: 'mach-b', runs: ['u3'], runAgg: 'max' }; state.metric = 'exec_time'; state.sampleAgg = 'min'; state.noise = 3; @@ -176,7 +176,7 @@ describe('round-trip', () => { it('round-trips multiple run UUIDs', () => { const state = makeDefaults(); state.sideA.runs = ['aaa-111', 'bbb-222', 'ccc-333']; - state.sideA.order = 'x'; // needed to trigger sideA encoding + state.sideA.commit = 'x'; // needed to trigger sideA encoding const qs = encodeToUrl(state); const decoded = decodeFromUrl(qs); @@ -192,9 +192,9 @@ describe('applyUrlState', () => { }); it('restores state from URL on page load', () => { - applyUrlState('?order_a=rev1&machine_a=mach-a&metric=exec_time&noise=3&sort=ratio&sort_dir=asc'); + applyUrlState('?commit_a=rev1&machine_a=mach-a&metric=exec_time&noise=3&sort=ratio&sort_dir=asc'); const s = getState(); - expect(s.sideA.order).toBe('rev1'); + expect(s.sideA.commit).toBe('rev1'); expect(s.sideA.machine).toBe('mach-a'); expect(s.metric).toBe('exec_time'); expect(s.noise).toBe(3); @@ -217,14 +217,14 @@ describe('applyUrlState', () => { expect(s.sortDir).toBe('desc'); // default expect(s.testFilter).toBe(''); // default expect(s.hideNoise).toBe(false); // default - expect(s.sideA).toEqual({ suite: '', order: '', machine: '', runs: [], runAgg: 'median' }); - expect(s.sideB).toEqual({ suite: '', order: '', machine: '', runs: [], runAgg: 'median' }); + expect(s.sideA).toEqual({ suite: '', commit: '', machine: '', runs: [], runAgg: 'median' }); + expect(s.sideB).toEqual({ suite: '', commit: '', machine: '', runs: [], runAgg: 'median' }); }); it('with empty search string sets state to all defaults', () => { // Set non-default state first setState({ metric: 'exec_time', noise: 5 }); - setSideA({ order: 'rev1', machine: 'mach-a' }); + setSideA({ commit: 'rev1', machine: 'mach-a' }); applyUrlState(''); const s = getState(); @@ -232,16 +232,16 @@ describe('applyUrlState', () => { }); it('with partial URL sets only specified fields, unset fields are defaults', () => { - applyUrlState('?order_b=rev2&sample_agg=min&hide_noise=1'); + applyUrlState('?commit_b=rev2&sample_agg=min&hide_noise=1'); const s = getState(); // Specified fields - expect(s.sideB.order).toBe('rev2'); + expect(s.sideB.commit).toBe('rev2'); expect(s.sampleAgg).toBe('min'); expect(s.hideNoise).toBe(true); // Unset fields should be defaults - expect(s.sideA).toEqual({ suite: '', order: '', machine: '', runs: [], runAgg: 'median' }); + expect(s.sideA).toEqual({ suite: '', commit: '', machine: '', runs: [], runAgg: 'median' }); expect(s.sideB.machine).toBe(''); expect(s.sideB.runs).toEqual([]); expect(s.sideB.runAgg).toBe('median'); @@ -275,9 +275,9 @@ describe('getState / setState / setSideA / setSideB', () => { }); it('setSideA merges partial side A selection', () => { - setSideA({ order: 'rev123', machine: 'mach-a' }); + setSideA({ commit: 'rev123', machine: 'mach-a' }); const s = getState(); - expect(s.sideA.order).toBe('rev123'); + expect(s.sideA.commit).toBe('rev123'); expect(s.sideA.machine).toBe('mach-a'); // Unset fields keep their defaults expect(s.sideA.runs).toEqual([]); @@ -290,87 +290,87 @@ describe('getState / setState / setSideA / setSideB', () => { expect(s.sideB.runs).toEqual(['uuid-1', 'uuid-2']); expect(s.sideB.runAgg).toBe('mean'); // Unset fields keep their defaults - expect(s.sideB.order).toBe(''); + expect(s.sideB.commit).toBe(''); expect(s.sideB.machine).toBe(''); }); it('state is preserved across calls (not reset)', () => { setState({ metric: 'exec_time' }); setState({ noise: 3 }); - setSideA({ order: 'rev1' }); + setSideA({ commit: 'rev1' }); setSideA({ machine: 'mach-a' }); - setSideB({ order: 'rev2' }); + setSideB({ commit: 'rev2' }); const s = getState(); // All previous calls should have been preserved expect(s.metric).toBe('exec_time'); expect(s.noise).toBe(3); - expect(s.sideA.order).toBe('rev1'); + expect(s.sideA.commit).toBe('rev1'); expect(s.sideA.machine).toBe('mach-a'); - expect(s.sideB.order).toBe('rev2'); + expect(s.sideB.commit).toBe('rev2'); }); it('swapSides exchanges sideA and sideB', () => { - setSideA({ order: 'rev1', machine: 'mach-a', runs: ['u1'], runAgg: 'mean' }); - setSideB({ order: 'rev2', machine: 'mach-b', runs: ['u2', 'u3'], runAgg: 'max' }); + setSideA({ commit: 'rev1', machine: 'mach-a', runs: ['u1'], runAgg: 'mean' }); + setSideB({ commit: 'rev2', machine: 'mach-b', runs: ['u2', 'u3'], runAgg: 'max' }); swapSides(); const s = getState(); - expect(s.sideA).toEqual({ suite: '', order: 'rev2', machine: 'mach-b', runs: ['u2', 'u3'], runAgg: 'max' }); - expect(s.sideB).toEqual({ suite: '', order: 'rev1', machine: 'mach-a', runs: ['u1'], runAgg: 'mean' }); + expect(s.sideA).toEqual({ suite: '', commit: 'rev2', machine: 'mach-b', runs: ['u2', 'u3'], runAgg: 'max' }); + expect(s.sideB).toEqual({ suite: '', commit: 'rev1', machine: 'mach-a', runs: ['u1'], runAgg: 'mean' }); }); it('swapSides twice restores original state', () => { - setSideA({ order: 'rev1', machine: 'mach-a' }); - setSideB({ order: 'rev2', machine: 'mach-b' }); + setSideA({ commit: 'rev1', machine: 'mach-a' }); + setSideB({ commit: 'rev2', machine: 'mach-b' }); swapSides(); swapSides(); const s = getState(); - expect(s.sideA.order).toBe('rev1'); + expect(s.sideA.commit).toBe('rev1'); expect(s.sideA.machine).toBe('mach-a'); - expect(s.sideB.order).toBe('rev2'); + expect(s.sideB.commit).toBe('rev2'); expect(s.sideB.machine).toBe('mach-b'); }); }); describe('URL special characters round-trip', () => { - it('round-trips order and machine with spaces', () => { + it('round-trips commit and machine with spaces', () => { const state = makeDefaults(); - state.sideA.order = 'rev 123'; + state.sideA.commit = 'rev 123'; state.sideA.machine = 'my machine'; const qs = encodeToUrl(state); const decoded = decodeFromUrl(qs); - expect(decoded.sideA?.order).toBe('rev 123'); + expect(decoded.sideA?.commit).toBe('rev 123'); expect(decoded.sideA?.machine).toBe('my machine'); }); it('round-trips values with +', () => { const state = makeDefaults(); - state.sideA.order = 'r+1'; + state.sideA.commit = 'r+1'; state.sideA.machine = 'host+name'; const qs = encodeToUrl(state); const decoded = decodeFromUrl(qs); - expect(decoded.sideA?.order).toBe('r+1'); + expect(decoded.sideA?.commit).toBe('r+1'); expect(decoded.sideA?.machine).toBe('host+name'); }); it('round-trips values with &', () => { const state = makeDefaults(); - state.sideA.order = 'a&b'; - state.sideB.order = 'c&d'; + state.sideA.commit = 'a&b'; + state.sideB.commit = 'c&d'; const qs = encodeToUrl(state); const decoded = decodeFromUrl(qs); - expect(decoded.sideA?.order).toBe('a&b'); - expect(decoded.sideB?.order).toBe('c&d'); + expect(decoded.sideA?.commit).toBe('a&b'); + expect(decoded.sideB?.commit).toBe('c&d'); }); it('round-trips values with =', () => { @@ -387,8 +387,8 @@ describe('URL special characters round-trip', () => { it('full round-trip with mixed special characters', () => { const state = makeDefaults(); - state.sideA = { suite: '', order: 'rev 123+rc1', machine: 'host&name=prod', runs: ['uuid-1'], runAgg: 'mean' }; - state.sideB = { suite: '', order: 'a&b=c+d e', machine: 'machine two', runs: ['uuid-2', 'uuid-3'], runAgg: 'max' }; + state.sideA = { suite: '', commit: 'rev 123+rc1', machine: 'host&name=prod', runs: ['uuid-1'], runAgg: 'mean' }; + state.sideB = { suite: '', commit: 'a&b=c+d e', machine: 'machine two', runs: ['uuid-2', 'uuid-3'], runAgg: 'max' }; state.metric = 'exec_time'; state.testFilter = 'bench+suite & more'; state.noise = 2; diff --git a/lnt/server/ui/v5/frontend/src/__tests__/utils.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/utils.test.ts index 5ed8fe726..fefe77dfe 100644 --- a/lnt/server/ui/v5/frontend/src/__tests__/utils.test.ts +++ b/lnt/server/ui/v5/frontend/src/__tests__/utils.test.ts @@ -9,7 +9,7 @@ vi.mock('../router', () => ({ import { median, mean, safeMin, safeMax, getAggFn, geomean, formatValue, formatPercent, formatRatio, formatTime, - truncate, primaryOrderValue, + truncate, debounce, el, isModifiedClick, spaLink, } from '../utils'; import { navigate } from '../router'; @@ -352,20 +352,6 @@ describe('truncate', () => { }); }); -describe('primaryOrderValue', () => { - it('returns first value from a single-field record', () => { - expect(primaryOrderValue({ rev: '12345' })).toBe('12345'); - }); - - it('returns first value from a multi-field record', () => { - expect(primaryOrderValue({ rev: '123', branch: 'main' })).toBe('123'); - }); - - it('returns empty string for an empty record', () => { - expect(primaryOrderValue({})).toBe(''); - }); -}); - describe('isModifiedClick', () => { it('returns false for a plain left click', () => { const e = new MouseEvent('click', { button: 0 }); diff --git a/lnt/server/ui/v5/frontend/src/api.ts b/lnt/server/ui/v5/frontend/src/api.ts index 4da9dcc17..3abc6c1d6 100644 --- a/lnt/server/ui/v5/frontend/src/api.ts +++ b/lnt/server/ui/v5/frontend/src/api.ts @@ -1,7 +1,7 @@ import type { APIKeyCreateResponse, APIKeyItem, CursorPaginated, FieldChangeInfo, FieldInfo, MachineInfo, MachineRunInfo, - OffsetPaginated, OrderDetail, OrderSummary, RunDetail, + OffsetPaginated, CommitDetail, CommitSummary, RunDetail, RunInfo, SampleInfo, TestSuiteInfo, } from './types'; @@ -172,12 +172,12 @@ export async function getFields(ts: string, signal?: AbortSignal): Promise void, -): Promise { - return fetchAllCursorPages(apiUrl(ts, 'orders'), undefined, signal, onProgress); +): Promise { + return fetchAllCursorPages(apiUrl(ts, 'commits'), undefined, signal, onProgress); } export async function getMachines( @@ -196,11 +196,11 @@ export async function getMachines( export async function getRuns( ts: string, - opts: { machine: string; order?: string }, + opts: { machine: string; commit?: string }, signal?: AbortSignal, ): Promise { const params: Record = { machine: opts.machine }; - if (opts.order) params.order = opts.order; + if (opts.commit) params.commit = opts.commit; return fetchAllCursorPages( apiUrl(ts, 'runs'), params, @@ -268,25 +268,25 @@ export async function deleteRun(ts: string, uuid: string): Promise { return fetchVoid(apiUrl(ts, `runs/${encodeURIComponent(uuid)}`), { method: 'DELETE' }); } -export async function getOrder( +export async function getCommit( ts: string, value: string, signal?: AbortSignal, -): Promise { - return fetchJson( - apiUrl(ts, `orders/${encodeURIComponent(value)}`), +): Promise { + return fetchJson( + apiUrl(ts, `commits/${encodeURIComponent(value)}`), { signal }, ); } -export async function getRunsByOrder( +export async function getRunsByCommit( ts: string, - orderValue: string, + commitValue: string, signal?: AbortSignal, ): Promise { return fetchAllCursorPages( apiUrl(ts, 'runs'), - { order: orderValue }, + { commit: commitValue }, signal, ); } @@ -305,16 +305,16 @@ export async function getFieldChanges( ); } -export async function searchOrdersByTag( +export async function searchCommits( ts: string, - tagPrefix: string, + searchPrefix: string, opts?: { limit?: number }, signal?: AbortSignal, -): Promise> { - const params: Record = { tag_prefix: tagPrefix }; +): Promise> { + const params: Record = { search: searchPrefix }; if (opts?.limit !== undefined) params.limit = String(opts.limit); - return fetchJson>( - apiUrl(ts, 'orders'), + return fetchJson>( + apiUrl(ts, 'commits'), { params, signal }, ); } @@ -333,28 +333,28 @@ export async function getRunsPage( return fetchOneCursorPage(apiUrl(ts, 'runs'), params, signal); } -/** Fetch one page of orders with optional tag_prefix filter (cursor-paginated). */ -export async function getOrdersPage( +/** Fetch one page of commits with optional search filter (cursor-paginated). */ +export async function getCommitsPage( ts: string, - opts?: { tagPrefix?: string; limit?: number; cursor?: string }, + opts?: { search?: string; limit?: number; cursor?: string }, signal?: AbortSignal, -): Promise> { +): Promise> { const params: Record = {}; - if (opts?.tagPrefix) params.tag_prefix = opts.tagPrefix; + if (opts?.search) params.search = opts.search; if (opts?.limit !== undefined) params.limit = String(opts.limit); if (opts?.cursor) params.cursor = opts.cursor; - return fetchOneCursorPage(apiUrl(ts, 'orders'), params, signal); + return fetchOneCursorPage(apiUrl(ts, 'commits'), params, signal); } -export async function updateOrderTag( +export async function updateCommit( ts: string, - orderValue: string, - tag: string | null, + commitValue: string, + updates: Record, signal?: AbortSignal, -): Promise { - return fetchJson( - apiUrl(ts, `orders/${encodeURIComponent(orderValue)}`), - { method: 'PATCH', body: { tag }, signal }, +): Promise { + return fetchJson( + apiUrl(ts, `commits/${encodeURIComponent(commitValue)}`), + { method: 'PATCH', body: updates, signal }, ); } @@ -411,8 +411,9 @@ export async function deleteTestSuite( export interface TrendsDataPoint { machine: string; - order: Record; - timestamp: string | null; + commit: string; + ordinal: number | null; + submitted_at: string | null; value: number; } diff --git a/lnt/server/ui/v5/frontend/src/main.ts b/lnt/server/ui/v5/frontend/src/main.ts index 23b5ae7f1..6279005c7 100644 --- a/lnt/server/ui/v5/frontend/src/main.ts +++ b/lnt/server/ui/v5/frontend/src/main.ts @@ -55,7 +55,7 @@ function init(): void { addRoute('/', suiteRedirectPage); addRoute('/machines/:name', machineDetailPage); addRoute('/runs/:uuid', runDetailPage); - addRoute('/orders/:value', orderDetailPage); + addRoute('/commits/:value', orderDetailPage); addRoute('/regressions', regressionListPage); addRoute('/regressions/:uuid', regressionDetailPage); addRoute('/field-changes', fieldChangeTriagePage); diff --git a/lnt/server/ui/v5/frontend/src/state.ts b/lnt/server/ui/v5/frontend/src/state.ts index 2a05d33d1..e04deffde 100644 --- a/lnt/server/ui/v5/frontend/src/state.ts +++ b/lnt/server/ui/v5/frontend/src/state.ts @@ -1,8 +1,8 @@ import type { AggFn, AppState, SideSelection, SortCol, SortDir } from './types'; const DEFAULTS: AppState = { - sideA: { suite: '', order: '', machine: '', runs: [], runAgg: 'median' }, - sideB: { suite: '', order: '', machine: '', runs: [], runAgg: 'median' }, + sideA: { suite: '', commit: '', machine: '', runs: [], runAgg: 'median' }, + sideB: { suite: '', commit: '', machine: '', runs: [], runAgg: 'median' }, metric: '', sampleAgg: 'median', noise: 1, @@ -50,14 +50,14 @@ function parseAgg(v: string | null): AggFn | undefined { function decodeSide(p: URLSearchParams, suffix: string): SideSelection | undefined { const suite = p.get(`suite_${suffix}`); - const order = p.get(`order_${suffix}`); + const commit = p.get(`commit_${suffix}`); const machine = p.get(`machine_${suffix}`); const runs = p.get(`runs_${suffix}`); const runAgg = parseAgg(p.get(`run_agg_${suffix}`)); - if (suite || order || machine || runs || runAgg) { + if (suite || commit || machine || runs || runAgg) { return { suite: suite || '', - order: order || '', + commit: commit || '', machine: machine || '', runs: runs ? runs.split(',').filter(Boolean) : [], runAgg: runAgg || 'median', @@ -68,7 +68,7 @@ function decodeSide(p: URLSearchParams, suffix: string): SideSelection | undefin function encodeSide(p: URLSearchParams, side: SideSelection, suffix: string): void { if (side.suite) p.set(`suite_${suffix}`, side.suite); - if (side.order) p.set(`order_${suffix}`, side.order); + if (side.commit) p.set(`commit_${suffix}`, side.commit); if (side.machine) p.set(`machine_${suffix}`, side.machine); if (side.runs.length) p.set(`runs_${suffix}`, side.runs.join(',')); if (side.runAgg !== 'median') p.set(`run_agg_${suffix}`, side.runAgg); diff --git a/lnt/server/ui/v5/frontend/src/types.ts b/lnt/server/ui/v5/frontend/src/types.ts index 9d44f24e8..bdf3b62ad 100644 --- a/lnt/server/ui/v5/frontend/src/types.ts +++ b/lnt/server/ui/v5/frontend/src/types.ts @@ -9,20 +9,23 @@ export interface FieldInfo { bigger_is_better: boolean | null; } -export interface OrderSummary { +export interface CommitSummary { + commit: string; + ordinal: number | null; fields: Record; - tag: string | null; } -export interface OrderDetail { +export interface CommitDetail { + commit: string; + ordinal: number | null; fields: Record; - tag: string | null; - previous_order: OrderNeighbor | null; - next_order: OrderNeighbor | null; + previous_commit: CommitNeighbor | null; + next_commit: CommitNeighbor | null; } -export interface OrderNeighbor { - fields: Record; +export interface CommitNeighbor { + commit: string; + ordinal: number | null; link: string; } @@ -34,27 +37,24 @@ export interface MachineInfo { export interface RunInfo { uuid: string; machine: string; - order: Record; - start_time: string | null; - end_time: string | null; - parameters?: Record; + commit: string; + submitted_at: string | null; + run_parameters?: Record; } -/** Run as returned by GET /machines/{name}/runs (no machine or parameters). */ +/** Run as returned by GET /machines/{name}/runs. */ export interface MachineRunInfo { uuid: string; - order: Record; - start_time: string | null; - end_time: string | null; + commit: string; + submitted_at: string | null; } export interface RunDetail { uuid: string; machine: string; - order: Record; - start_time: string | null; - end_time: string | null; - parameters: Record; + commit: string; + submitted_at: string | null; + run_parameters: Record; } export interface SampleInfo { @@ -70,9 +70,8 @@ export interface FieldChangeInfo { metric: string | null; old_value: number; new_value: number; - start_order: string | null; - end_order: string | null; - run_uuid: string | null; + start_commit: string | null; + end_commit: string | null; } export interface QueryDataPoint { @@ -80,9 +79,10 @@ export interface QueryDataPoint { machine: string; metric: string; value: number; - order: Record; + commit: string; + ordinal: number | null; run_uuid: string; - timestamp: string | null; + submitted_at: string | null; } export interface CursorPaginated { @@ -110,7 +110,7 @@ export type SortCol = 'test' | 'value_a' | 'value_b' | 'delta' | 'delta_pct' | ' export interface SideSelection { suite: string; - order: string; + commit: string; machine: string; runs: string[]; // UUIDs runAgg: AggFn; @@ -165,7 +165,7 @@ export interface TestSuiteInfo { schema: { metrics: FieldInfo[]; run_fields: Array<{ name: string; type: string }>; - order_fields: Array<{ name: string; type: string }>; + commit_fields: Array<{ name: string; type: string }>; machine_fields: Array<{ name: string; type: string }>; }; } diff --git a/lnt/server/ui/v5/frontend/src/utils.ts b/lnt/server/ui/v5/frontend/src/utils.ts index e5ae57867..55e2cfcc8 100644 --- a/lnt/server/ui/v5/frontend/src/utils.ts +++ b/lnt/server/ui/v5/frontend/src/utils.ts @@ -94,10 +94,6 @@ export function truncate(s: string, max: number): string { return s.length > max ? s.slice(0, max) + '\u2026' : s; } -/** Extract the primary (first) order field value from an order fields dict. */ -export function primaryOrderValue(fields: Record): string { - return Object.values(fields)[0] || ''; -} // DOM helpers From f9451126e1c1b704234134bf6f249662d7e55e22 Mon Sep 17 00:00:00 2001 From: Louis Dionne Date: Tue, 14 Apr 2026 15:14:07 -0400 Subject: [PATCH 052/143] [UI] Rebase Test Suites page from Order to Commit Rename Orders tab to Commits, update column definitions and API calls to use the new Commit model (plain commit string, ordinal, search param). Fix sort parameter from -start_time to -submitted_at to match the v5 API. Co-Authored-By: Claude Opus 4.6 (1M context) --- .../src/__tests__/pages/test-suites.test.ts | 60 ++++++++-------- .../ui/v5/frontend/src/pages/test-suites.ts | 70 +++++++++---------- 2 files changed, 62 insertions(+), 68 deletions(-) diff --git a/lnt/server/ui/v5/frontend/src/__tests__/pages/test-suites.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/pages/test-suites.test.ts index 70da52864..777f34d22 100644 --- a/lnt/server/ui/v5/frontend/src/__tests__/pages/test-suites.test.ts +++ b/lnt/server/ui/v5/frontend/src/__tests__/pages/test-suites.test.ts @@ -8,7 +8,7 @@ vi.mock('../../api', async (importOriginal) => { ...actual, getMachines: vi.fn(), getRunsPage: vi.fn(), - getOrdersPage: vi.fn(), + getCommitsPage: vi.fn(), }; }); @@ -31,11 +31,11 @@ vi.mock('../../router', async (importOriginal) => { // Mock lnt_url_base (globalThis as unknown as Record).lnt_url_base = ''; -import { getMachines, getRunsPage, getOrdersPage } from '../../api'; +import { getMachines, getRunsPage, getCommitsPage } from '../../api'; import type { CursorPageResult } from '../../api'; import { getTestsuites } from '../../router'; import { testSuitesPage } from '../../pages/test-suites'; -import type { RunInfo, MachineInfo, OrderSummary } from '../../types'; +import type { RunInfo, MachineInfo, CommitSummary } from '../../types'; const mockMachines: MachineInfo[] = [ { name: 'clang-x86', info: { os: 'linux' } }, @@ -43,20 +43,20 @@ const mockMachines: MachineInfo[] = [ ]; const mockRuns: RunInfo[] = [ - { uuid: 'aaaa-1111', machine: 'clang-x86', order: { rev: '100' }, start_time: '2026-01-01T10:00:00Z', end_time: null }, - { uuid: 'bbbb-2222', machine: 'gcc-arm', order: { rev: '101' }, start_time: '2026-01-02T10:00:00Z', end_time: null }, + { uuid: 'aaaa-1111', machine: 'clang-x86', commit: '100', submitted_at: '2026-01-01T10:00:00Z' }, + { uuid: 'bbbb-2222', machine: 'gcc-arm', commit: '101', submitted_at: '2026-01-02T10:00:00Z' }, ]; -const mockOrders: OrderSummary[] = [ - { fields: { rev: '100' }, tag: 'v1.0' }, - { fields: { rev: '101' }, tag: null }, +const mockCommits: CommitSummary[] = [ + { commit: '100', ordinal: 1, fields: {} }, + { commit: '101', ordinal: null, fields: {} }, ]; function mockRunsPage(items: RunInfo[], nextCursor: string | null = null): CursorPageResult { return { items, nextCursor }; } -function mockOrdersPage(items: OrderSummary[], nextCursor: string | null = null): CursorPageResult { +function mockCommitsPage(items: CommitSummary[], nextCursor: string | null = null): CursorPageResult { return { items, nextCursor }; } @@ -78,8 +78,8 @@ describe('testSuitesPage', () => { (getRunsPage as ReturnType).mockResolvedValue( mockRunsPage(mockRuns), ); - (getOrdersPage as ReturnType).mockResolvedValue( - mockOrdersPage(mockOrders), + (getCommitsPage as ReturnType).mockResolvedValue( + mockCommitsPage(mockCommits), ); // Clear URL query params @@ -128,7 +128,7 @@ describe('testSuitesPage', () => { expect(tabs[0].textContent).toBe('Recent Activity'); expect(tabs[1].textContent).toBe('Machines'); expect(tabs[2].textContent).toBe('Runs'); - expect(tabs[3].textContent).toBe('Orders'); + expect(tabs[3].textContent).toBe('Commits'); }); it('highlights the selected suite card', () => { @@ -154,7 +154,7 @@ describe('testSuitesPage', () => { await vi.waitFor(() => { expect(getRunsPage).toHaveBeenCalledWith( 'nts', - expect.objectContaining({ sort: '-start_time', limit: 25 }), + expect.objectContaining({ sort: '-submitted_at', limit: 25 }), expect.any(AbortSignal), ); }); @@ -167,8 +167,8 @@ describe('testSuitesPage', () => { await vi.waitFor(() => { const headers = Array.from(container.querySelectorAll('th')).map(h => h.textContent); expect(headers).toContain('Machine'); - expect(headers).toContain('Order'); - expect(headers).toContain('Start Time'); + expect(headers).toContain('Commit'); + expect(headers).toContain('Submitted'); expect(headers).toContain('Run'); }); }); @@ -226,7 +226,7 @@ describe('testSuitesPage', () => { // Should call getRunsPage (once for Recent Activity, once for Runs tab) const calls = (getRunsPage as ReturnType).mock.calls; const runsTabCall = calls.find( - (c: unknown[]) => c[1]?.sort === '-start_time', + (c: unknown[]) => c[1]?.sort === '-submitted_at', ); expect(runsTabCall).toBeTruthy(); }); @@ -247,17 +247,17 @@ describe('testSuitesPage', () => { }); }); - it('Orders tab loads orders with cursor pagination', async () => { + it('Commits tab loads commits with cursor pagination', async () => { testSuitesPage.mount(container, { testsuite: '' }); (container.querySelector('.suite-card') as HTMLElement).click(); - // Click Orders tab - const ordersTab = Array.from(container.querySelectorAll('.v5-tab')) - .find(t => t.textContent === 'Orders') as HTMLElement; - ordersTab.click(); + // Click Commits tab + const commitsTab = Array.from(container.querySelectorAll('.v5-tab')) + .find(t => t.textContent === 'Commits') as HTMLElement; + commitsTab.click(); await vi.waitFor(() => { - expect(getOrdersPage).toHaveBeenCalledWith( + expect(getCommitsPage).toHaveBeenCalledWith( 'nts', expect.objectContaining({ limit: 25 }), expect.any(AbortSignal), @@ -265,7 +265,7 @@ describe('testSuitesPage', () => { }); }); - it('Orders tab shows order values and tags', async () => { + it('Commits tab shows commit values and ordinals', async () => { testSuitesPage.mount(container, { testsuite: '' }); (container.querySelector('.suite-card') as HTMLElement).click(); @@ -274,17 +274,17 @@ describe('testSuitesPage', () => { expect(container.querySelector('table')).toBeTruthy(); }); - const ordersTab = Array.from(container.querySelectorAll('.v5-tab')) - .find(t => t.textContent === 'Orders') as HTMLElement; - ordersTab.click(); + const commitsTab = Array.from(container.querySelectorAll('.v5-tab')) + .find(t => t.textContent === 'Commits') as HTMLElement; + commitsTab.click(); await vi.waitFor(() => { - // Check the table has Order and Tag columns + // Check the table has Commit and Ordinal columns const headers = Array.from(container.querySelectorAll('th')).map(h => h.textContent); - expect(headers).toContain('Order'); - expect(headers).toContain('Tag'); + expect(headers).toContain('Commit'); + expect(headers).toContain('Ordinal'); expect(container.textContent).toContain('100'); - expect(container.textContent).toContain('v1.0'); + expect(container.textContent).toContain('1'); expect(container.textContent).toContain('101'); }); }); diff --git a/lnt/server/ui/v5/frontend/src/pages/test-suites.ts b/lnt/server/ui/v5/frontend/src/pages/test-suites.ts index cb7751652..ee95a722f 100644 --- a/lnt/server/ui/v5/frontend/src/pages/test-suites.ts +++ b/lnt/server/ui/v5/frontend/src/pages/test-suites.ts @@ -2,18 +2,18 @@ // Suite-agnostic — served at /v5/test-suites. import type { PageModule, RouteParams } from '../router'; -import type { MachineInfo, RunInfo, OrderSummary } from '../types'; +import type { MachineInfo, RunInfo, CommitSummary } from '../types'; import type { CursorPageResult } from '../api'; import { getTestsuites } from '../router'; -import { getMachines, getRunsPage, getOrdersPage } from '../api'; +import { getMachines, getRunsPage, getCommitsPage } from '../api'; import type { Column } from '../components/data-table'; -import { el, formatTime, truncate, primaryOrderValue, debounce } from '../utils'; +import { el, formatTime, truncate, debounce } from '../utils'; import { renderDataTable } from '../components/data-table'; import { renderPagination } from '../components/pagination'; const PAGE_SIZE = 25; -type TabId = 'recent' | 'machines' | 'runs' | 'orders'; +type TabId = 'recent' | 'machines' | 'runs' | 'commits'; let tabController: AbortController | null = null; @@ -72,7 +72,7 @@ export const testSuitesPage: PageModule = { { id: 'recent', label: 'Recent Activity' }, { id: 'machines', label: 'Machines' }, { id: 'runs', label: 'Runs' }, - { id: 'orders', label: 'Orders' }, + { id: 'commits', label: 'Commits' }, ]; const tabButtons: HTMLElement[] = []; for (const tab of tabDefs) { @@ -148,23 +148,23 @@ export const testSuitesPage: PageModule = { 'Failed to load runs', (s, opts, sig) => getRunsPage(s, { machine: opts.search || undefined, - sort: '-start_time', + sort: '-submitted_at', limit: opts.limit, cursor: opts.cursor, }, sig), runsColumns(selectedSuite), (search: string) => { currentSearch = search; syncUrl(); }); break; - case 'orders': + case 'commits': renderCursorPaginatedTab(tabContent, selectedSuite, currentSearch, signal, - 'Filter by tag...', 'Loading orders...', 'No orders found.', - 'Failed to load orders', - (s, opts, sig) => getOrdersPage(s, { - tagPrefix: opts.search || undefined, + 'Search commits...', 'Loading commits...', 'No commits found.', + 'Failed to load commits', + (s, opts, sig) => getCommitsPage(s, { + search: opts.search || undefined, limit: opts.limit, cursor: opts.cursor, }, sig), - ordersColumns(selectedSuite), + commitsColumns(selectedSuite), (search: string) => { currentSearch = search; syncUrl(); }); break; } @@ -202,7 +202,7 @@ function renderRecentActivityTab( async function loadPage(): Promise { try { const result = await getRunsPage(suite, { - sort: '-start_time', + sort: '-submitted_at', limit: PAGE_SIZE, cursor: nextCursor || undefined, }, signal); @@ -251,13 +251,11 @@ function recentActivityColumns(suite: string): Column[] { { key: 'machine', label: 'Machine', render: (r: RunInfo) => detailLink(r.machine, suite, `/machines/${encodeURIComponent(r.machine)}`) }, - { key: 'order', label: 'Order', - render: (r: RunInfo) => { - const val = primaryOrderValue(r.order); - return detailLink(val, suite, `/orders/${encodeURIComponent(val)}`); - } }, - { key: 'start_time', label: 'Start Time', - render: (r: RunInfo) => formatTime(r.start_time) }, + { key: 'commit', label: 'Commit', + render: (r: RunInfo) => + detailLink(r.commit, suite, `/commits/${encodeURIComponent(r.commit)}`) }, + { key: 'submitted_at', label: 'Submitted', + render: (r: RunInfo) => formatTime(r.submitted_at) }, { key: 'uuid', label: 'Run', render: (r: RunInfo) => detailLink(truncate(r.uuid, 8), suite, `/runs/${encodeURIComponent(r.uuid)}`) }, @@ -353,7 +351,7 @@ function formatMachineInfo(m: MachineInfo): string { } // --------------------------------------------------------------------------- -// Cursor-paginated tab (shared by Runs and Orders) +// Cursor-paginated tab (shared by Runs and Commits) // --------------------------------------------------------------------------- interface CursorFetchOpts { @@ -364,7 +362,7 @@ interface CursorFetchOpts { /** * Generic cursor-paginated tab with search input, data table, and Previous/Next. - * Used by the Runs and Orders tabs. + * Used by the Runs and Commits tabs. */ function renderCursorPaginatedTab( container: HTMLElement, @@ -458,25 +456,21 @@ function runsColumns(suite: string): Column[] { { key: 'machine', label: 'Machine', render: (r: RunInfo) => detailLink(r.machine, suite, `/machines/${encodeURIComponent(r.machine)}`) }, - { key: 'order', label: 'Order', - render: (r: RunInfo) => { - const val = primaryOrderValue(r.order); - return detailLink(truncate(val, 12), suite, - `/orders/${encodeURIComponent(val)}`); - } }, - { key: 'start_time', label: 'Start Time', - render: (r: RunInfo) => formatTime(r.start_time) }, + { key: 'commit', label: 'Commit', + render: (r: RunInfo) => + detailLink(truncate(r.commit, 12), suite, + `/commits/${encodeURIComponent(r.commit)}`) }, + { key: 'submitted_at', label: 'Submitted', + render: (r: RunInfo) => formatTime(r.submitted_at) }, ]; } -function ordersColumns(suite: string): Column[] { +function commitsColumns(suite: string): Column[] { return [ - { key: 'order', label: 'Order', - render: (o: OrderSummary) => { - const val = primaryOrderValue(o.fields); - return detailLink(val, suite, `/orders/${encodeURIComponent(val)}`); - } }, - { key: 'tag', label: 'Tag', - render: (o: OrderSummary) => o.tag || '\u2014' }, + { key: 'commit', label: 'Commit', + render: (o: CommitSummary) => + detailLink(o.commit, suite, `/commits/${encodeURIComponent(o.commit)}`) }, + { key: 'ordinal', label: 'Ordinal', + render: (o: CommitSummary) => o.ordinal != null ? String(o.ordinal) : '\u2014' }, ]; } From 4c470d324a6c0a440cede0369a528b3869fd010b Mon Sep 17 00:00:00 2001 From: Louis Dionne Date: Tue, 14 Apr 2026 15:37:14 -0400 Subject: [PATCH 053/143] [UI] Rename Order Detail to Commit Detail, add display field support Rename order-detail to commit-detail, replace tag editing with ordinal editing, update prev/next navigation to use commit strings. Add commitDisplayValue() utility for schema-driven display fields and display flag to TestSuiteInfo commit_fields type. Co-Authored-By: Claude Opus 4.6 (1M context) --- ...r-detail.test.ts => commit-detail.test.ts} | 157 +++++++++--------- .../v5/frontend/src/__tests__/utils.test.ts | 27 +++ lnt/server/ui/v5/frontend/src/main.ts | 4 +- .../{order-detail.ts => commit-detail.ts} | 85 +++++----- lnt/server/ui/v5/frontend/src/types.ts | 2 +- lnt/server/ui/v5/frontend/src/utils.ts | 19 +++ 6 files changed, 172 insertions(+), 122 deletions(-) rename lnt/server/ui/v5/frontend/src/__tests__/pages/{order-detail.test.ts => commit-detail.test.ts} (63%) rename lnt/server/ui/v5/frontend/src/pages/{order-detail.ts => commit-detail.ts} (66%) diff --git a/lnt/server/ui/v5/frontend/src/__tests__/pages/order-detail.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/pages/commit-detail.test.ts similarity index 63% rename from lnt/server/ui/v5/frontend/src/__tests__/pages/order-detail.test.ts rename to lnt/server/ui/v5/frontend/src/__tests__/pages/commit-detail.test.ts index 0bdc83e2e..bc02b9a09 100644 --- a/lnt/server/ui/v5/frontend/src/__tests__/pages/order-detail.test.ts +++ b/lnt/server/ui/v5/frontend/src/__tests__/pages/commit-detail.test.ts @@ -6,9 +6,9 @@ vi.mock('../../api', async (importOriginal) => { const actual = await importOriginal(); return { ...actual, - getOrder: vi.fn(), - getRunsByOrder: vi.fn(), - updateOrderTag: vi.fn(), + getCommit: vi.fn(), + getRunsByCommit: vi.fn(), + updateCommit: vi.fn(), authErrorMessage: vi.fn((err: unknown) => `Auth error: ${err}`), }; }); @@ -32,25 +32,26 @@ vi.mock('../../router', async (importOriginal) => { Fx: { hover: vi.fn(), unhover: vi.fn() }, }; -import { getOrder, getRunsByOrder, updateOrderTag, authErrorMessage } from '../../api'; +import { getCommit, getRunsByCommit, updateCommit, authErrorMessage } from '../../api'; import { navigate } from '../../router'; -import { orderDetailPage } from '../../pages/order-detail'; -import type { OrderDetail, RunInfo } from '../../types'; +import { commitDetailPage } from '../../pages/commit-detail'; +import type { CommitDetail, RunInfo } from '../../types'; -const mockOrder: OrderDetail = { +const mockCommit: CommitDetail = { + commit: '100', + ordinal: 42, fields: { rev: '100' }, - tag: 'v1.0', - previous_order: { fields: { rev: '99' }, link: '/orders/99' }, - next_order: { fields: { rev: '101' }, link: '/orders/101' }, + previous_commit: { commit: '99', ordinal: 41, link: '/commits/99' }, + next_commit: { commit: '101', ordinal: 43, link: '/commits/101' }, }; const mockRuns: RunInfo[] = [ - { uuid: 'aaaa-1111', machine: 'clang-x86', order: { rev: '100' }, start_time: '2026-01-01T10:00:00Z', end_time: null }, - { uuid: 'bbbb-2222', machine: 'clang-x86', order: { rev: '100' }, start_time: '2026-01-01T11:00:00Z', end_time: null }, - { uuid: 'cccc-3333', machine: 'gcc-arm', order: { rev: '100' }, start_time: '2026-01-01T12:00:00Z', end_time: null }, + { uuid: 'aaaa-1111', machine: 'clang-x86', commit: '100', submitted_at: '2026-01-01T10:00:00Z' }, + { uuid: 'bbbb-2222', machine: 'clang-x86', commit: '100', submitted_at: '2026-01-01T11:00:00Z' }, + { uuid: 'cccc-3333', machine: 'gcc-arm', commit: '100', submitted_at: '2026-01-01T12:00:00Z' }, ]; -describe('orderDetailPage', () => { +describe('commitDetailPage', () => { let container: HTMLElement; beforeEach(() => { @@ -58,31 +59,31 @@ describe('orderDetailPage', () => { vi.useFakeTimers(); container = document.createElement('div'); - (getOrder as ReturnType).mockResolvedValue(mockOrder); - (getRunsByOrder as ReturnType).mockResolvedValue(mockRuns); - (updateOrderTag as ReturnType).mockResolvedValue({ ...mockOrder, tag: 'new-tag' }); + (getCommit as ReturnType).mockResolvedValue(mockCommit); + (getRunsByCommit as ReturnType).mockResolvedValue(mockRuns); + (updateCommit as ReturnType).mockResolvedValue({ ...mockCommit, ordinal: 99 }); }); afterEach(() => { - orderDetailPage.unmount?.(); + commitDetailPage.unmount?.(); vi.useRealTimers(); }); - it('renders page header with order value', () => { - orderDetailPage.mount(container, { testsuite: 'nts', value: '100' }); + it('renders page header with commit value', () => { + commitDetailPage.mount(container, { testsuite: 'nts', value: '100' }); - expect(container.querySelector('.page-header')?.textContent).toBe('Order: 100'); + expect(container.querySelector('.page-header')?.textContent).toBe('Commit: 100'); }); - it('calls getOrder and getRunsByOrder in parallel', () => { - orderDetailPage.mount(container, { testsuite: 'nts', value: '100' }); + it('calls getCommit and getRunsByCommit in parallel', () => { + commitDetailPage.mount(container, { testsuite: 'nts', value: '100' }); - expect(getOrder).toHaveBeenCalledWith('nts', '100', expect.any(AbortSignal)); - expect(getRunsByOrder).toHaveBeenCalledWith('nts', '100', expect.any(AbortSignal)); + expect(getCommit).toHaveBeenCalledWith('nts', '100', expect.any(AbortSignal)); + expect(getRunsByCommit).toHaveBeenCalledWith('nts', '100', expect.any(AbortSignal)); }); - it('renders order fields as dl key-value pairs', async () => { - orderDetailPage.mount(container, { testsuite: 'nts', value: '100' }); + it('renders commit fields as dl key-value pairs', async () => { + commitDetailPage.mount(container, { testsuite: 'nts', value: '100' }); await vi.waitFor(() => { const dl = container.querySelector('.metadata-dl'); @@ -92,21 +93,21 @@ describe('orderDetailPage', () => { }); }); - it('shows tag value and Edit button', async () => { - orderDetailPage.mount(container, { testsuite: 'nts', value: '100' }); + it('shows ordinal value and Edit button', async () => { + commitDetailPage.mount(container, { testsuite: 'nts', value: '100' }); await vi.waitFor(() => { const tagDisplay = container.querySelector('.tag-display'); expect(tagDisplay).toBeTruthy(); - expect(tagDisplay!.textContent).toContain('v1.0'); + expect(tagDisplay!.textContent).toContain('42'); expect(tagDisplay!.querySelector('button')?.textContent).toBe('Edit'); }); }); - it('shows "(none)" when tag is null', async () => { - (getOrder as ReturnType).mockResolvedValue({ ...mockOrder, tag: null }); + it('shows "(none)" when ordinal is null', async () => { + (getCommit as ReturnType).mockResolvedValue({ ...mockCommit, ordinal: null }); - orderDetailPage.mount(container, { testsuite: 'nts', value: '100' }); + commitDetailPage.mount(container, { testsuite: 'nts', value: '100' }); await vi.waitFor(() => { const tagDisplay = container.querySelector('.tag-display'); @@ -115,7 +116,7 @@ describe('orderDetailPage', () => { }); it('clicking Edit shows inline edit form with input, Save, Cancel', async () => { - orderDetailPage.mount(container, { testsuite: 'nts', value: '100' }); + commitDetailPage.mount(container, { testsuite: 'nts', value: '100' }); await vi.waitFor(() => { expect(container.querySelector('.tag-display button')).toBeTruthy(); @@ -129,7 +130,7 @@ describe('orderDetailPage', () => { const tagContainer = container.querySelector('.tag-display')!; const input = tagContainer.querySelector('input') as HTMLInputElement; expect(input).toBeTruthy(); - expect(input.value).toBe('v1.0'); // pre-filled + expect(input.value).toBe('42'); // pre-filled const buttons = tagContainer.querySelectorAll('button'); const buttonTexts = Array.from(buttons).map(b => b.textContent); @@ -138,7 +139,7 @@ describe('orderDetailPage', () => { }); it('Cancel returns to display mode without API call', async () => { - orderDetailPage.mount(container, { testsuite: 'nts', value: '100' }); + commitDetailPage.mount(container, { testsuite: 'nts', value: '100' }); await vi.waitFor(() => { expect(container.querySelector('.tag-display button')).toBeTruthy(); @@ -153,13 +154,13 @@ describe('orderDetailPage', () => { cancelBtn.click(); // Should be back to display mode - expect(container.querySelector('.tag-display')!.textContent).toContain('v1.0'); + expect(container.querySelector('.tag-display')!.textContent).toContain('42'); expect(container.querySelector('.tag-display')!.textContent).toContain('Edit'); - expect(updateOrderTag).not.toHaveBeenCalled(); + expect(updateCommit).not.toHaveBeenCalled(); }); - it('Save calls updateOrderTag and re-renders tag on success', async () => { - orderDetailPage.mount(container, { testsuite: 'nts', value: '100' }); + it('Save calls updateCommit and re-renders ordinal on success', async () => { + commitDetailPage.mount(container, { testsuite: 'nts', value: '100' }); await vi.waitFor(() => { expect(container.querySelector('.tag-display button')).toBeTruthy(); @@ -170,23 +171,23 @@ describe('orderDetailPage', () => { // Change value and click Save const input = container.querySelector('.tag-display input') as HTMLInputElement; - input.value = 'new-tag'; + input.value = '99'; const saveBtn = Array.from(container.querySelectorAll('.tag-display button')) .find(b => b.textContent === 'Save') as HTMLElement; saveBtn.click(); await vi.waitFor(() => { - expect(updateOrderTag).toHaveBeenCalledWith('nts', '100', 'new-tag'); - // Should be back in display mode with new tag - expect(container.querySelector('.tag-display')!.textContent).toContain('new-tag'); + expect(updateCommit).toHaveBeenCalledWith('nts', '100', { ordinal: 99 }); + // Should be back in display mode with new ordinal + expect(container.querySelector('.tag-display')!.textContent).toContain('99'); }); }); it('Save shows error on failure and re-enables button', async () => { - (updateOrderTag as ReturnType).mockRejectedValue(new Error('403 forbidden')); + (updateCommit as ReturnType).mockRejectedValue(new Error('403 forbidden')); - orderDetailPage.mount(container, { testsuite: 'nts', value: '100' }); + commitDetailPage.mount(container, { testsuite: 'nts', value: '100' }); await vi.waitFor(() => { expect(container.querySelector('.tag-display button')).toBeTruthy(); @@ -209,11 +210,11 @@ describe('orderDetailPage', () => { }); }); - it('renders Previous button when previous_order exists', async () => { - orderDetailPage.mount(container, { testsuite: 'nts', value: '100' }); + it('renders Previous button when previous_commit exists', async () => { + commitDetailPage.mount(container, { testsuite: 'nts', value: '100' }); await vi.waitFor(() => { - const navContainer = container.querySelector('.order-nav'); + const navContainer = container.querySelector('.commit-nav'); expect(navContainer).toBeTruthy(); const prevBtn = Array.from(navContainer!.querySelectorAll('button')) .find(b => b.textContent?.includes('Previous')); @@ -221,11 +222,11 @@ describe('orderDetailPage', () => { }); }); - it('renders Next button when next_order exists', async () => { - orderDetailPage.mount(container, { testsuite: 'nts', value: '100' }); + it('renders Next button when next_commit exists', async () => { + commitDetailPage.mount(container, { testsuite: 'nts', value: '100' }); await vi.waitFor(() => { - const navContainer = container.querySelector('.order-nav'); + const navContainer = container.querySelector('.commit-nav'); const nextBtn = Array.from(navContainer!.querySelectorAll('button')) .find(b => b.textContent?.includes('Next')); expect(nextBtn).toBeTruthy(); @@ -233,38 +234,38 @@ describe('orderDetailPage', () => { }); it('does not render Previous/Next when neighbors are null', async () => { - (getOrder as ReturnType).mockResolvedValue({ - ...mockOrder, - previous_order: null, - next_order: null, + (getCommit as ReturnType).mockResolvedValue({ + ...mockCommit, + previous_commit: null, + next_commit: null, }); - orderDetailPage.mount(container, { testsuite: 'nts', value: '100' }); + commitDetailPage.mount(container, { testsuite: 'nts', value: '100' }); await vi.waitFor(() => { - const navContainer = container.querySelector('.order-nav'); + const navContainer = container.querySelector('.commit-nav'); expect(navContainer).toBeTruthy(); expect(navContainer!.querySelectorAll('button')).toHaveLength(0); }); }); - it('clicking Previous navigates to previous order', async () => { - orderDetailPage.mount(container, { testsuite: 'nts', value: '100' }); + it('clicking Previous navigates to previous commit', async () => { + commitDetailPage.mount(container, { testsuite: 'nts', value: '100' }); await vi.waitFor(() => { - const navContainer = container.querySelector('.order-nav'); + const navContainer = container.querySelector('.commit-nav'); expect(navContainer!.querySelectorAll('button').length).toBeGreaterThan(0); }); - const prevBtn = Array.from(container.querySelector('.order-nav')!.querySelectorAll('button')) + const prevBtn = Array.from(container.querySelector('.commit-nav')!.querySelectorAll('button')) .find(b => b.textContent?.includes('Previous')) as HTMLElement; prevBtn.click(); - expect(navigate).toHaveBeenCalledWith(expect.stringContaining('/orders/99')); + expect(navigate).toHaveBeenCalledWith(expect.stringContaining('/commits/99')); }); it('renders runs summary', async () => { - orderDetailPage.mount(container, { testsuite: 'nts', value: '100' }); + commitDetailPage.mount(container, { testsuite: 'nts', value: '100' }); await vi.waitFor(() => { // 3 runs across 2 machines @@ -272,19 +273,19 @@ describe('orderDetailPage', () => { }); }); - it('renders runs table with Machine, Run UUID, Start Time columns', async () => { - orderDetailPage.mount(container, { testsuite: 'nts', value: '100' }); + it('renders runs table with Machine, Run UUID, Submitted columns', async () => { + commitDetailPage.mount(container, { testsuite: 'nts', value: '100' }); await vi.waitFor(() => { const headers = Array.from(container.querySelectorAll('th')).map(h => h.textContent); expect(headers).toContain('Machine'); expect(headers).toContain('Run UUID'); - expect(headers).toContain('Start Time'); + expect(headers).toContain('Submitted'); }); }); it('machine and run links use suite-scoped hrefs', async () => { - orderDetailPage.mount(container, { testsuite: 'nts', value: '100' }); + commitDetailPage.mount(container, { testsuite: 'nts', value: '100' }); await vi.waitFor(() => { const machineLink = container.querySelector('a[href*="/machines/"]') as HTMLAnchorElement; @@ -298,7 +299,7 @@ describe('orderDetailPage', () => { }); it('machine filter filters runs by machine name after 200ms debounce', async () => { - orderDetailPage.mount(container, { testsuite: 'nts', value: '100' }); + commitDetailPage.mount(container, { testsuite: 'nts', value: '100' }); await vi.waitFor(() => { expect(container.querySelector('table')).toBeTruthy(); @@ -319,7 +320,7 @@ describe('orderDetailPage', () => { }); it('filtered summary shows "X of Y runs across A of B machines"', async () => { - orderDetailPage.mount(container, { testsuite: 'nts', value: '100' }); + commitDetailPage.mount(container, { testsuite: 'nts', value: '100' }); await vi.waitFor(() => { expect(container.querySelector('table')).toBeTruthy(); @@ -337,7 +338,7 @@ describe('orderDetailPage', () => { }); it('shows "No runs matching filter." when filter matches nothing', async () => { - orderDetailPage.mount(container, { testsuite: 'nts', value: '100' }); + commitDetailPage.mount(container, { testsuite: 'nts', value: '100' }); await vi.waitFor(() => { expect(container.querySelector('table')).toBeTruthy(); @@ -354,22 +355,22 @@ describe('orderDetailPage', () => { }); it('shows error banner on initial load failure', async () => { - (getOrder as ReturnType).mockRejectedValue(new Error('Not found')); + (getCommit as ReturnType).mockRejectedValue(new Error('Not found')); - orderDetailPage.mount(container, { testsuite: 'nts', value: '100' }); + commitDetailPage.mount(container, { testsuite: 'nts', value: '100' }); await vi.waitFor(() => { const banner = container.querySelector('.error-banner'); expect(banner).toBeTruthy(); - expect(banner!.textContent).toContain('Failed to load order'); + expect(banner!.textContent).toContain('Failed to load commit'); }); }); it('unmount aborts without error', () => { - (getOrder as ReturnType).mockReturnValue(new Promise(() => {})); - (getRunsByOrder as ReturnType).mockReturnValue(new Promise(() => {})); + (getCommit as ReturnType).mockReturnValue(new Promise(() => {})); + (getRunsByCommit as ReturnType).mockReturnValue(new Promise(() => {})); - orderDetailPage.mount(container, { testsuite: 'nts', value: '100' }); - expect(() => orderDetailPage.unmount!()).not.toThrow(); + commitDetailPage.mount(container, { testsuite: 'nts', value: '100' }); + expect(() => commitDetailPage.unmount!()).not.toThrow(); }); }); diff --git a/lnt/server/ui/v5/frontend/src/__tests__/utils.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/utils.test.ts index fefe77dfe..11a4a60a0 100644 --- a/lnt/server/ui/v5/frontend/src/__tests__/utils.test.ts +++ b/lnt/server/ui/v5/frontend/src/__tests__/utils.test.ts @@ -11,6 +11,7 @@ import { formatValue, formatPercent, formatRatio, formatTime, truncate, debounce, el, isModifiedClick, spaLink, + commitDisplayValue, } from '../utils'; import { navigate } from '../router'; @@ -420,3 +421,29 @@ describe('spaLink', () => { expect(navigate).not.toHaveBeenCalled(); }); }); + +describe('commitDisplayValue', () => { + it('returns commit string when no commitFields provided', () => { + expect(commitDisplayValue('abc123', { rev: 'v1.0' })).toBe('abc123'); + }); + + it('returns commit string when no display field in schema', () => { + const fields = [{ name: 'rev' }]; + expect(commitDisplayValue('abc123', { rev: 'v1.0' }, fields)).toBe('abc123'); + }); + + it('returns display field value when display=true and value exists', () => { + const fields = [{ name: 'rev', display: true }]; + expect(commitDisplayValue('abc123', { rev: 'v1.0' }, fields)).toBe('v1.0'); + }); + + it('falls back to commit string when display field value is empty', () => { + const fields = [{ name: 'rev', display: true }]; + expect(commitDisplayValue('abc123', {}, fields)).toBe('abc123'); + }); + + it('falls back to commit string when display field value is missing', () => { + const fields = [{ name: 'tag', display: true }]; + expect(commitDisplayValue('abc123', { rev: 'v1.0' }, fields)).toBe('abc123'); + }); +}); diff --git a/lnt/server/ui/v5/frontend/src/main.ts b/lnt/server/ui/v5/frontend/src/main.ts index 6279005c7..33b029861 100644 --- a/lnt/server/ui/v5/frontend/src/main.ts +++ b/lnt/server/ui/v5/frontend/src/main.ts @@ -11,7 +11,7 @@ import { homePage } from './pages/home'; import { testSuitesPage } from './pages/test-suites'; import { machineDetailPage } from './pages/machine-detail'; import { runDetailPage } from './pages/run-detail'; -import { orderDetailPage } from './pages/order-detail'; +import { commitDetailPage } from './pages/commit-detail'; import { graphPage } from './pages/graph'; import { comparePage } from './pages/compare'; import { regressionListPage } from './pages/regression-list'; @@ -55,7 +55,7 @@ function init(): void { addRoute('/', suiteRedirectPage); addRoute('/machines/:name', machineDetailPage); addRoute('/runs/:uuid', runDetailPage); - addRoute('/commits/:value', orderDetailPage); + addRoute('/commits/:value', commitDetailPage); addRoute('/regressions', regressionListPage); addRoute('/regressions/:uuid', regressionDetailPage); addRoute('/field-changes', fieldChangeTriagePage); diff --git a/lnt/server/ui/v5/frontend/src/pages/order-detail.ts b/lnt/server/ui/v5/frontend/src/pages/commit-detail.ts similarity index 66% rename from lnt/server/ui/v5/frontend/src/pages/order-detail.ts rename to lnt/server/ui/v5/frontend/src/pages/commit-detail.ts index 8a3978be9..1baf47efd 100644 --- a/lnt/server/ui/v5/frontend/src/pages/order-detail.ts +++ b/lnt/server/ui/v5/frontend/src/pages/commit-detail.ts @@ -1,28 +1,28 @@ -// pages/order-detail.ts — Order detail with tag editing, prev/next, machine filter, runs table. +// pages/commit-detail.ts — Commit detail with ordinal editing, prev/next, machine filter, runs table. import type { PageModule, RouteParams } from '../router'; -import type { RunInfo, OrderDetail } from '../types'; -import { getOrder, getRunsByOrder, updateOrderTag, authErrorMessage } from '../api'; -import { el, spaLink, formatTime, primaryOrderValue, debounce } from '../utils'; +import type { RunInfo, CommitDetail } from '../types'; +import { getCommit, getRunsByCommit, updateCommit, authErrorMessage } from '../api'; +import { el, spaLink, formatTime, debounce } from '../utils'; import { navigate } from '../router'; import { renderDataTable } from '../components/data-table'; let controller: AbortController | null = null; -export const orderDetailPage: PageModule = { +export const commitDetailPage: PageModule = { mount(container: HTMLElement, params: RouteParams): void { if (controller) controller.abort(); controller = new AbortController(); const { signal } = controller; const ts = params.testsuite; - const orderValue = params.value; + const commitValue = params.value; - container.append(el('h2', { class: 'page-header' }, `Order: ${orderValue}`)); + container.append(el('h2', { class: 'page-header' }, `Commit: ${commitValue}`)); - const fieldsContainer = el('div', { class: 'order-fields' }); + const fieldsContainer = el('div', { class: 'commit-fields' }); const tagContainer = el('div', { class: 'tag-display' }); - const navContainer = el('div', { class: 'order-nav' }); + const navContainer = el('div', { class: 'commit-nav' }); const summaryContainer = el('div', {}); const filterContainer = el('div', { class: 'table-controls' }); const tableContainer = el('div', {}); @@ -31,40 +31,38 @@ export const orderDetailPage: PageModule = { summaryContainer, filterContainer, tableContainer, ); - const loading = el('p', { class: 'progress-label' }, 'Loading order data...'); + const loading = el('p', { class: 'progress-label' }, 'Loading commit data...'); container.append(loading); let runs: RunInfo[] = []; let machineFilter = ''; Promise.all([ - getOrder(ts, orderValue, signal), - getRunsByOrder(ts, orderValue, signal), - ]).then(([order, orderRuns]) => { + getCommit(ts, commitValue, signal), + getRunsByCommit(ts, commitValue, signal), + ]).then(([commit, commitRuns]) => { loading.remove(); - runs = orderRuns; + runs = commitRuns; // Order fields const dl = el('dl', { class: 'metadata-dl' }); - for (const [k, v] of Object.entries(order.fields)) { + for (const [k, v] of Object.entries(commit.fields)) { dl.append(el('dt', {}, k), el('dd', {}, v || '')); } fieldsContainer.append(dl); // Tag display + edit - renderTag(tagContainer, ts, orderValue, order); + renderOrdinal(tagContainer, ts, commitValue, commit); // Prev/Next navigation - if (order.previous_order) { - const prevValue = primaryOrderValue(order.previous_order.fields); + if (commit.previous_commit) { const prevBtn = el('button', { class: 'pagination-btn' }, '\u2190 Previous'); - prevBtn.addEventListener('click', () => navigate(`/orders/${encodeURIComponent(prevValue)}`)); + prevBtn.addEventListener('click', () => navigate(`/commits/${encodeURIComponent(commit.previous_commit!.commit)}`)); navContainer.append(prevBtn); } - if (order.next_order) { - const nextValue = primaryOrderValue(order.next_order.fields); + if (commit.next_commit) { const nextBtn = el('button', { class: 'pagination-btn' }, 'Next \u2192'); - nextBtn.addEventListener('click', () => navigate(`/orders/${encodeURIComponent(nextValue)}`)); + nextBtn.addEventListener('click', () => navigate(`/commits/${encodeURIComponent(commit.next_commit!.commit)}`)); navContainer.append(nextBtn); } @@ -84,7 +82,7 @@ export const orderDetailPage: PageModule = { renderSummaryAndTable(); }).catch(e => { loading.remove(); - container.append(el('p', { class: 'error-banner' }, `Failed to load order: ${e}`)); + container.append(el('p', { class: 'error-banner' }, `Failed to load commit: ${e}`)); }); function filteredRuns(): RunInfo[] { @@ -115,11 +113,11 @@ export const orderDetailPage: PageModule = { render: (r: RunInfo) => spaLink(r.machine, `/machines/${encodeURIComponent(r.machine)}`) }, { key: 'uuid', label: 'Run UUID', render: (r: RunInfo) => spaLink(r.uuid.slice(0, 8), `/runs/${encodeURIComponent(r.uuid)}`) }, - { key: 'start_time', label: 'Start Time', - render: (r: RunInfo) => formatTime(r.start_time) }, + { key: 'submitted_at', label: 'Submitted', + render: (r: RunInfo) => formatTime(r.submitted_at) }, ], rows: visible, - emptyMessage: machineFilter ? 'No runs matching filter.' : 'No runs at this order.', + emptyMessage: machineFilter ? 'No runs matching filter.' : 'No runs at this commit.', }); } }, @@ -129,30 +127,29 @@ export const orderDetailPage: PageModule = { }, }; -function renderTag( +function renderOrdinal( container: HTMLElement, ts: string, - orderValue: string, - order: OrderDetail, + commitValue: string, + commit: CommitDetail, ): void { container.replaceChildren(); - const tagLabel = el('strong', {}, 'Tag: '); - const tagValue = el('span', {}, order.tag || '(none)'); + const label = el('strong', {}, 'Ordinal: '); + const value = el('span', {}, commit.ordinal != null ? String(commit.ordinal) : '(none)'); const editBtn = el('button', { class: 'pagination-btn' }, 'Edit'); - container.append(tagLabel, tagValue, editBtn); + container.append(label, value, editBtn); editBtn.addEventListener('click', () => { container.replaceChildren(); - container.append(el('strong', {}, 'Tag: ')); + container.append(el('strong', {}, 'Ordinal: ')); const input = el('input', { type: 'text', class: 'tag-edit-input combobox-input', - placeholder: 'Enter tag (max 64 chars)...', - maxlength: '64', + placeholder: 'Enter ordinal (integer)...', }) as HTMLInputElement; - input.value = order.tag || ''; + input.value = commit.ordinal != null ? String(commit.ordinal) : ''; input.style.width = '200px'; const saveBtn = el('button', { class: 'compare-btn' }, 'Save') as HTMLButtonElement; @@ -162,16 +159,22 @@ function renderTag( container.append(input, saveBtn, cancelBtn, errorEl); input.focus(); - cancelBtn.addEventListener('click', () => renderTag(container, ts, orderValue, order)); + cancelBtn.addEventListener('click', () => renderOrdinal(container, ts, commitValue, commit)); saveBtn.addEventListener('click', async () => { saveBtn.disabled = true; errorEl.textContent = ''; - const newTag = input.value.trim() || null; + const raw = input.value.trim(); + const newOrdinal = raw === '' ? null : parseInt(raw, 10); + if (raw !== '' && (isNaN(newOrdinal!) || !Number.isInteger(newOrdinal))) { + errorEl.textContent = 'Ordinal must be an integer'; + saveBtn.disabled = false; + return; + } try { - const updated = await updateOrderTag(ts, orderValue, newTag); - order.tag = updated.tag; - renderTag(container, ts, orderValue, order); + const updated = await updateCommit(ts, commitValue, { ordinal: newOrdinal }); + commit.ordinal = updated.ordinal; + renderOrdinal(container, ts, commitValue, commit); } catch (e: unknown) { errorEl.textContent = authErrorMessage(e); saveBtn.disabled = false; diff --git a/lnt/server/ui/v5/frontend/src/types.ts b/lnt/server/ui/v5/frontend/src/types.ts index bdf3b62ad..369ae2dd2 100644 --- a/lnt/server/ui/v5/frontend/src/types.ts +++ b/lnt/server/ui/v5/frontend/src/types.ts @@ -165,7 +165,7 @@ export interface TestSuiteInfo { schema: { metrics: FieldInfo[]; run_fields: Array<{ name: string; type: string }>; - commit_fields: Array<{ name: string; type: string }>; + commit_fields: Array<{ name: string; type: string; display?: boolean }>; machine_fields: Array<{ name: string; type: string }>; }; } diff --git a/lnt/server/ui/v5/frontend/src/utils.ts b/lnt/server/ui/v5/frontend/src/utils.ts index 55e2cfcc8..2fa197525 100644 --- a/lnt/server/ui/v5/frontend/src/utils.ts +++ b/lnt/server/ui/v5/frontend/src/utils.ts @@ -95,6 +95,25 @@ export function truncate(s: string, max: number): string { } +/** + * Return the display value for a commit. If the schema defines a commit_field + * with display=true and the commit's fields dict has a non-null value for it, + * return that value. Otherwise, return the raw commit string. + */ +export function commitDisplayValue( + commit: string, + fields: Record, + commitFields?: Array<{ name: string; display?: boolean }>, +): string { + if (commitFields) { + const displayField = commitFields.find(f => f.display); + if (displayField && fields[displayField.name]) { + return fields[displayField.name]; + } + } + return commit; +} + // DOM helpers export function debounce void>(fn: T, ms: number): T { From 31188b5c9a34cefc4ef0793ec00fb1ff2eded017 Mon Sep 17 00:00:00 2001 From: Louis Dionne Date: Tue, 14 Apr 2026 15:43:32 -0400 Subject: [PATCH 054/143] [UI] Clean up stale tag/order terminology in commit-detail Rename tag-display/tag-edit CSS classes to ordinal-display/ordinal-edit, fix stale "Order fields" comment, rename local variables from tag* to ordinal* for consistency with the new Commit model. Co-Authored-By: Claude Opus 4.6 (1M context) --- .../src/__tests__/pages/commit-detail.test.ts | 52 +++++++++---------- .../ui/v5/frontend/src/pages/commit-detail.ts | 10 ++-- lnt/server/ui/v5/frontend/src/style.css | 4 +- 3 files changed, 33 insertions(+), 33 deletions(-) diff --git a/lnt/server/ui/v5/frontend/src/__tests__/pages/commit-detail.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/pages/commit-detail.test.ts index bc02b9a09..f9dd319fa 100644 --- a/lnt/server/ui/v5/frontend/src/__tests__/pages/commit-detail.test.ts +++ b/lnt/server/ui/v5/frontend/src/__tests__/pages/commit-detail.test.ts @@ -97,10 +97,10 @@ describe('commitDetailPage', () => { commitDetailPage.mount(container, { testsuite: 'nts', value: '100' }); await vi.waitFor(() => { - const tagDisplay = container.querySelector('.tag-display'); - expect(tagDisplay).toBeTruthy(); - expect(tagDisplay!.textContent).toContain('42'); - expect(tagDisplay!.querySelector('button')?.textContent).toBe('Edit'); + const ordinalDisplay = container.querySelector('.ordinal-display'); + expect(ordinalDisplay).toBeTruthy(); + expect(ordinalDisplay!.textContent).toContain('42'); + expect(ordinalDisplay!.querySelector('button')?.textContent).toBe('Edit'); }); }); @@ -110,8 +110,8 @@ describe('commitDetailPage', () => { commitDetailPage.mount(container, { testsuite: 'nts', value: '100' }); await vi.waitFor(() => { - const tagDisplay = container.querySelector('.tag-display'); - expect(tagDisplay!.textContent).toContain('(none)'); + const ordinalDisplay = container.querySelector('.ordinal-display'); + expect(ordinalDisplay!.textContent).toContain('(none)'); }); }); @@ -119,20 +119,20 @@ describe('commitDetailPage', () => { commitDetailPage.mount(container, { testsuite: 'nts', value: '100' }); await vi.waitFor(() => { - expect(container.querySelector('.tag-display button')).toBeTruthy(); + expect(container.querySelector('.ordinal-display button')).toBeTruthy(); }); // Click Edit - const editBtn = container.querySelector('.tag-display button') as HTMLElement; + const editBtn = container.querySelector('.ordinal-display button') as HTMLElement; editBtn.click(); // Should now show input, Save, Cancel - const tagContainer = container.querySelector('.tag-display')!; - const input = tagContainer.querySelector('input') as HTMLInputElement; + const ordinalContainer = container.querySelector('.ordinal-display')!; + const input = ordinalContainer.querySelector('input') as HTMLInputElement; expect(input).toBeTruthy(); expect(input.value).toBe('42'); // pre-filled - const buttons = tagContainer.querySelectorAll('button'); + const buttons = ordinalContainer.querySelectorAll('button'); const buttonTexts = Array.from(buttons).map(b => b.textContent); expect(buttonTexts).toContain('Save'); expect(buttonTexts).toContain('Cancel'); @@ -142,20 +142,20 @@ describe('commitDetailPage', () => { commitDetailPage.mount(container, { testsuite: 'nts', value: '100' }); await vi.waitFor(() => { - expect(container.querySelector('.tag-display button')).toBeTruthy(); + expect(container.querySelector('.ordinal-display button')).toBeTruthy(); }); // Click Edit - (container.querySelector('.tag-display button') as HTMLElement).click(); + (container.querySelector('.ordinal-display button') as HTMLElement).click(); // Click Cancel - const cancelBtn = Array.from(container.querySelectorAll('.tag-display button')) + const cancelBtn = Array.from(container.querySelectorAll('.ordinal-display button')) .find(b => b.textContent === 'Cancel') as HTMLElement; cancelBtn.click(); // Should be back to display mode - expect(container.querySelector('.tag-display')!.textContent).toContain('42'); - expect(container.querySelector('.tag-display')!.textContent).toContain('Edit'); + expect(container.querySelector('.ordinal-display')!.textContent).toContain('42'); + expect(container.querySelector('.ordinal-display')!.textContent).toContain('Edit'); expect(updateCommit).not.toHaveBeenCalled(); }); @@ -163,24 +163,24 @@ describe('commitDetailPage', () => { commitDetailPage.mount(container, { testsuite: 'nts', value: '100' }); await vi.waitFor(() => { - expect(container.querySelector('.tag-display button')).toBeTruthy(); + expect(container.querySelector('.ordinal-display button')).toBeTruthy(); }); // Click Edit - (container.querySelector('.tag-display button') as HTMLElement).click(); + (container.querySelector('.ordinal-display button') as HTMLElement).click(); // Change value and click Save - const input = container.querySelector('.tag-display input') as HTMLInputElement; + const input = container.querySelector('.ordinal-display input') as HTMLInputElement; input.value = '99'; - const saveBtn = Array.from(container.querySelectorAll('.tag-display button')) + const saveBtn = Array.from(container.querySelectorAll('.ordinal-display button')) .find(b => b.textContent === 'Save') as HTMLElement; saveBtn.click(); await vi.waitFor(() => { expect(updateCommit).toHaveBeenCalledWith('nts', '100', { ordinal: 99 }); // Should be back in display mode with new ordinal - expect(container.querySelector('.tag-display')!.textContent).toContain('99'); + expect(container.querySelector('.ordinal-display')!.textContent).toContain('99'); }); }); @@ -190,21 +190,21 @@ describe('commitDetailPage', () => { commitDetailPage.mount(container, { testsuite: 'nts', value: '100' }); await vi.waitFor(() => { - expect(container.querySelector('.tag-display button')).toBeTruthy(); + expect(container.querySelector('.ordinal-display button')).toBeTruthy(); }); - (container.querySelector('.tag-display button') as HTMLElement).click(); + (container.querySelector('.ordinal-display button') as HTMLElement).click(); - const saveBtn = Array.from(container.querySelectorAll('.tag-display button')) + const saveBtn = Array.from(container.querySelectorAll('.ordinal-display button')) .find(b => b.textContent === 'Save') as HTMLButtonElement; saveBtn.click(); await vi.waitFor(() => { expect(authErrorMessage).toHaveBeenCalled(); - const errorEl = container.querySelector('.tag-display .error-banner'); + const errorEl = container.querySelector('.ordinal-display .error-banner'); expect(errorEl).toBeTruthy(); // Save button should be re-enabled - const currentSaveBtn = Array.from(container.querySelectorAll('.tag-display button')) + const currentSaveBtn = Array.from(container.querySelectorAll('.ordinal-display button')) .find(b => b.textContent === 'Save') as HTMLButtonElement; expect(currentSaveBtn.disabled).toBe(false); }); diff --git a/lnt/server/ui/v5/frontend/src/pages/commit-detail.ts b/lnt/server/ui/v5/frontend/src/pages/commit-detail.ts index 1baf47efd..89797e69b 100644 --- a/lnt/server/ui/v5/frontend/src/pages/commit-detail.ts +++ b/lnt/server/ui/v5/frontend/src/pages/commit-detail.ts @@ -21,13 +21,13 @@ export const commitDetailPage: PageModule = { container.append(el('h2', { class: 'page-header' }, `Commit: ${commitValue}`)); const fieldsContainer = el('div', { class: 'commit-fields' }); - const tagContainer = el('div', { class: 'tag-display' }); + const ordinalContainer = el('div', { class: 'ordinal-display' }); const navContainer = el('div', { class: 'commit-nav' }); const summaryContainer = el('div', {}); const filterContainer = el('div', { class: 'table-controls' }); const tableContainer = el('div', {}); container.append( - fieldsContainer, tagContainer, navContainer, + fieldsContainer, ordinalContainer, navContainer, summaryContainer, filterContainer, tableContainer, ); @@ -44,7 +44,7 @@ export const commitDetailPage: PageModule = { loading.remove(); runs = commitRuns; - // Order fields + // Commit fields const dl = el('dl', { class: 'metadata-dl' }); for (const [k, v] of Object.entries(commit.fields)) { dl.append(el('dt', {}, k), el('dd', {}, v || '')); @@ -52,7 +52,7 @@ export const commitDetailPage: PageModule = { fieldsContainer.append(dl); // Tag display + edit - renderOrdinal(tagContainer, ts, commitValue, commit); + renderOrdinal(ordinalContainer, ts, commitValue, commit); // Prev/Next navigation if (commit.previous_commit) { @@ -146,7 +146,7 @@ function renderOrdinal( const input = el('input', { type: 'text', - class: 'tag-edit-input combobox-input', + class: 'ordinal-edit-input combobox-input', placeholder: 'Enter ordinal (integer)...', }) as HTMLInputElement; input.value = commit.ordinal != null ? String(commit.ordinal) : ''; diff --git a/lnt/server/ui/v5/frontend/src/style.css b/lnt/server/ui/v5/frontend/src/style.css index a486c56ad..f9c8d0697 100644 --- a/lnt/server/ui/v5/frontend/src/style.css +++ b/lnt/server/ui/v5/frontend/src/style.css @@ -874,7 +874,7 @@ dl { margin: 10px 0; } -.tag-display { +.ordinal-display { display: flex; align-items: center; gap: 8px; @@ -882,7 +882,7 @@ dl { font-size: 13px; } -.tag-edit-input { +.ordinal-edit-input { padding: 4px 8px; border: 1px solid #ccc; border-radius: 3px; From 283535153a22bcdad31a348bbf52dcc0c42900b9 Mon Sep 17 00:00:00 2001 From: Louis Dionne Date: Tue, 14 Apr 2026 16:10:29 -0400 Subject: [PATCH 055/143] [UI] Rename Order Search to Commit Search Replace OrderSuggestion with CommitSummary, use searchCommits API instead of searchOrdersByTag, show ordinal/display-field as secondary info instead of tags. Rename all CSS classes from order-search-* to commit-search-*. Co-Authored-By: Claude Opus 4.6 (1M context) --- ...r-search.test.ts => commit-search.test.ts} | 56 +++++----- .../{order-search.ts => commit-search.ts} | 103 +++++++++--------- lnt/server/ui/v5/frontend/src/style.css | 14 +-- 3 files changed, 88 insertions(+), 85 deletions(-) rename lnt/server/ui/v5/frontend/src/__tests__/{order-search.test.ts => commit-search.test.ts} (76%) rename lnt/server/ui/v5/frontend/src/components/{order-search.ts => commit-search.ts} (61%) diff --git a/lnt/server/ui/v5/frontend/src/__tests__/order-search.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/commit-search.test.ts similarity index 76% rename from lnt/server/ui/v5/frontend/src/__tests__/order-search.test.ts rename to lnt/server/ui/v5/frontend/src/__tests__/commit-search.test.ts index 81d265646..1930396fe 100644 --- a/lnt/server/ui/v5/frontend/src/__tests__/order-search.test.ts +++ b/lnt/server/ui/v5/frontend/src/__tests__/commit-search.test.ts @@ -3,17 +3,17 @@ import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; // Mock modules before importing the component vi.mock('../api', () => ({ - searchOrdersByTag: vi.fn(), + searchCommits: vi.fn(), })); vi.mock('../router', () => ({ navigate: vi.fn(), })); -import { renderOrderSearch } from '../components/order-search'; -import { searchOrdersByTag } from '../api'; +import { renderCommitSearch } from '../components/commit-search'; +import { searchCommits } from '../api'; import { navigate } from '../router'; -const mockSearch = searchOrdersByTag as ReturnType; +const mockSearch = searchCommits as ReturnType; const mockNavigate = navigate as ReturnType; beforeEach(() => { @@ -28,25 +28,25 @@ afterEach(() => { vi.restoreAllMocks(); }); -function cursorPage(items: Array<{ fields: Record; tag: string | null }>) { +function cursorPage(items: Array<{ commit: string; ordinal: number | null; fields: Record }>) { return { items, cursor: { next: null, previous: null } }; } -describe('renderOrderSearch', () => { +describe('renderCommitSearch', () => { it('renders an input and dropdown into the container', () => { const container = document.createElement('div'); - renderOrderSearch(container, { testsuite: 'nts' }); + renderCommitSearch(container, { testsuite: 'nts' }); - expect(container.querySelector('input.order-search-input')).not.toBeNull(); - expect(container.querySelector('ul.order-search-dropdown')).not.toBeNull(); + expect(container.querySelector('input.commit-search-input')).not.toBeNull(); + expect(container.querySelector('ul.commit-search-dropdown')).not.toBeNull(); }); - it('calls searchOrdersByTag after debounce on input', async () => { + it('calls searchCommits after debounce on input', async () => { mockSearch.mockResolvedValue(cursorPage([])); const container = document.createElement('div'); document.body.append(container); - renderOrderSearch(container, { testsuite: 'nts' }); + renderCommitSearch(container, { testsuite: 'nts' }); const input = container.querySelector('input') as HTMLInputElement; input.value = 'release'; @@ -61,15 +61,15 @@ describe('renderOrderSearch', () => { expect(mockSearch).toHaveBeenCalledWith('nts', 'release', { limit: 10 }, expect.anything()); }); - it('shows dropdown with results including tags', async () => { + it('shows dropdown with results including secondary info', async () => { mockSearch.mockResolvedValue(cursorPage([ - { fields: { rev: 'abc123' }, tag: 'release-18' }, - { fields: { rev: 'def456' }, tag: null }, + { commit: 'abc123', ordinal: 1, fields: {} }, + { commit: 'def456', ordinal: null, fields: {} }, ])); const container = document.createElement('div'); document.body.append(container); - renderOrderSearch(container, { testsuite: 'nts' }); + renderCommitSearch(container, { testsuite: 'nts' }); const input = container.querySelector('input') as HTMLInputElement; input.value = 'rel'; @@ -82,18 +82,18 @@ describe('renderOrderSearch', () => { const items = dropdown.querySelectorAll('li'); expect(items).toHaveLength(2); expect(items[0].textContent).toContain('abc123'); - expect(items[0].textContent).toContain('(release-18)'); + expect(items[0].textContent).toContain('#1'); expect(items[1].textContent).toContain('def456'); }); it('navigates on dropdown item click', async () => { mockSearch.mockResolvedValue(cursorPage([ - { fields: { rev: 'abc123' }, tag: 'release-18' }, + { commit: 'abc123', ordinal: 1, fields: {} }, ])); const container = document.createElement('div'); document.body.append(container); - renderOrderSearch(container, { testsuite: 'nts' }); + renderCommitSearch(container, { testsuite: 'nts' }); const input = container.querySelector('input') as HTMLInputElement; input.value = 'rel'; @@ -103,19 +103,19 @@ describe('renderOrderSearch', () => { const item = container.querySelector('li') as HTMLElement; item.click(); - expect(mockNavigate).toHaveBeenCalledWith('/orders/abc123'); + expect(mockNavigate).toHaveBeenCalledWith('/commits/abc123'); expect(input.value).toBe(''); }); it('calls onSelect instead of navigate when provided', async () => { mockSearch.mockResolvedValue(cursorPage([ - { fields: { rev: 'abc123' }, tag: null }, + { commit: 'abc123', ordinal: null, fields: {} }, ])); const onSelect = vi.fn(); const container = document.createElement('div'); document.body.append(container); - renderOrderSearch(container, { testsuite: 'nts', onSelect }); + renderCommitSearch(container, { testsuite: 'nts', onSelect }); const input = container.querySelector('input') as HTMLInputElement; input.value = 'abc'; @@ -132,23 +132,23 @@ describe('renderOrderSearch', () => { it('navigates to typed value on Enter', () => { const container = document.createElement('div'); document.body.append(container); - renderOrderSearch(container, { testsuite: 'nts' }); + renderCommitSearch(container, { testsuite: 'nts' }); const input = container.querySelector('input') as HTMLInputElement; input.value = 'exact-hash'; input.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter' })); - expect(mockNavigate).toHaveBeenCalledWith('/orders/exact-hash'); + expect(mockNavigate).toHaveBeenCalledWith('/commits/exact-hash'); }); it('closes dropdown on Escape', async () => { mockSearch.mockResolvedValue(cursorPage([ - { fields: { rev: 'abc' }, tag: null }, + { commit: 'abc', ordinal: null, fields: {} }, ])); const container = document.createElement('div'); document.body.append(container); - renderOrderSearch(container, { testsuite: 'nts' }); + renderCommitSearch(container, { testsuite: 'nts' }); const input = container.querySelector('input') as HTMLInputElement; input.value = 'abc'; @@ -165,7 +165,7 @@ describe('renderOrderSearch', () => { it('hides dropdown when input is empty', async () => { const container = document.createElement('div'); document.body.append(container); - renderOrderSearch(container, { testsuite: 'nts' }); + renderCommitSearch(container, { testsuite: 'nts' }); const input = container.querySelector('input') as HTMLInputElement; input.value = ''; @@ -182,7 +182,7 @@ describe('renderOrderSearch', () => { const container = document.createElement('div'); document.body.append(container); - renderOrderSearch(container, { testsuite: 'nts' }); + renderCommitSearch(container, { testsuite: 'nts' }); const input = container.querySelector('input') as HTMLInputElement; input.value = 'nothing'; @@ -196,7 +196,7 @@ describe('renderOrderSearch', () => { it('destroy() removes document click listener', () => { const container = document.createElement('div'); document.body.append(container); - const handle = renderOrderSearch(container, { testsuite: 'nts' }); + const handle = renderCommitSearch(container, { testsuite: 'nts' }); const spy = vi.spyOn(document, 'removeEventListener'); handle.destroy(); diff --git a/lnt/server/ui/v5/frontend/src/components/order-search.ts b/lnt/server/ui/v5/frontend/src/components/commit-search.ts similarity index 61% rename from lnt/server/ui/v5/frontend/src/components/order-search.ts rename to lnt/server/ui/v5/frontend/src/components/commit-search.ts index 4103a7628..e8e09e433 100644 --- a/lnt/server/ui/v5/frontend/src/components/order-search.ts +++ b/lnt/server/ui/v5/frontend/src/components/commit-search.ts @@ -1,53 +1,51 @@ -// components/order-search.ts — Order search with tag-based autocomplete. +// components/commit-search.ts — Commit search with prefix autocomplete. -import { el, debounce, primaryOrderValue } from '../utils'; -import { searchOrdersByTag } from '../api'; +import { el, debounce, commitDisplayValue } from '../utils'; +import { searchCommits } from '../api'; +import type { CommitSummary } from '../types'; import { navigate } from '../router'; -export interface OrderSuggestion { - orderValue: string; - tag: string | null; -} - -export interface OrderSearchOptions { +export interface CommitSearchOptions { testsuite: string; placeholder?: string; - /** If provided, called instead of navigating to Order Detail. */ - onSelect?: (orderValue: string) => void; - /** Pre-loaded suggestions shown on focus. Tagged orders should come first. */ - suggestions?: OrderSuggestion[]; + /** If provided, called instead of navigating to Commit Detail. */ + onSelect?: (commitValue: string) => void; + /** Pre-loaded suggestions shown on focus. Commits with ordinals should come first. */ + suggestions?: CommitSummary[]; + /** Schema commit_fields for display field resolution. */ + commitFields?: Array<{ name: string; display?: boolean }>; } -let orderSearchCounter = 0; +let commitSearchCounter = 0; /** - * Render an order search input with autocomplete dropdown. + * Render a commit search input with autocomplete dropdown. * * - If suggestions are provided, shows them on focus (filtered by input text) - * - Otherwise, typing triggers a debounced tag_prefix search via the API + * - Otherwise, typing triggers a debounced search via the API * - Enter selects the current input value directly - * - Clicking a dropdown item selects that order + * - Clicking a dropdown item selects that commit */ -export function renderOrderSearch( +export function renderCommitSearch( container: HTMLElement, - options: OrderSearchOptions, -): { destroy: () => void; setSuggestions: (s: OrderSuggestion[]) => void } { - const dropdownId = `order-search-list-${++orderSearchCounter}`; + options: CommitSearchOptions, +): { destroy: () => void; setSuggestions: (s: CommitSummary[]) => void } { + const dropdownId = `commit-search-list-${++commitSearchCounter}`; const wrapper = el('div', { - class: 'order-search', + class: 'commit-search', role: 'combobox', 'aria-expanded': 'false', 'aria-haspopup': 'listbox', }); const input = el('input', { type: 'text', - class: 'order-search-input combobox-input', - placeholder: options.placeholder || 'Search by order value or tag...', + class: 'commit-search-input combobox-input', + placeholder: options.placeholder || 'Search commits...', role: 'searchbox', 'aria-autocomplete': 'list', 'aria-controls': dropdownId, }) as HTMLInputElement; - const dropdown = el('ul', { class: 'order-search-dropdown combobox-dropdown', role: 'listbox', id: dropdownId }); + const dropdown = el('ul', { class: 'commit-search-dropdown combobox-dropdown', role: 'listbox', id: dropdownId }); wrapper.append(input, dropdown); container.append(wrapper); @@ -55,19 +53,19 @@ export function renderOrderSearch( dropdown.addEventListener('mousedown', (e) => e.preventDefault()); let abortCtrl: AbortController | null = null; - let suggestions: OrderSuggestion[] = options.suggestions || []; + let suggestions: CommitSummary[] = options.suggestions || []; // When suggestions are explicitly provided (even as []), use suggestions mode: // only show from the suggestions list, never fall back to API search. const useSuggestionsMode = options.suggestions !== undefined; - function selectOrder(value: string): void { + function selectCommit(value: string): void { input.value = ''; dropdown.classList.remove('open'); wrapper.setAttribute('aria-expanded', 'false'); if (options.onSelect) { options.onSelect(value); } else { - navigate(`/orders/${encodeURIComponent(value)}`); + navigate(`/commits/${encodeURIComponent(value)}`); } } @@ -75,8 +73,8 @@ export function renderOrderSearch( const text = input.value.trim().toLowerCase(); const filtered = text ? suggestions.filter(s => - s.orderValue.toLowerCase().startsWith(text) || - (s.tag && s.tag.toLowerCase().startsWith(text))) + s.commit.toLowerCase().startsWith(text) || + Object.values(s.fields).some(v => v.toLowerCase().startsWith(text))) : suggestions; dropdown.replaceChildren(); @@ -87,11 +85,14 @@ export function renderOrderSearch( } for (const s of filtered) { const li = el('li', { class: 'combobox-item', tabindex: '-1' }); - li.append(el('span', {}, s.orderValue)); - if (s.tag) { - li.append(el('span', { class: 'order-search-tag' }, ` (${s.tag})`)); + li.append(el('span', {}, s.commit)); + const display = commitDisplayValue(s.commit, s.fields, options.commitFields); + if (display !== s.commit) { + li.append(el('span', { class: 'commit-search-field' }, ` (${display})`)); + } else if (s.ordinal != null) { + li.append(el('span', { class: 'commit-search-field' }, ` #${s.ordinal}`)); } - li.addEventListener('click', () => selectOrder(s.orderValue)); + li.addEventListener('click', () => selectCommit(s.commit)); dropdown.append(li); } dropdown.classList.add('open'); @@ -109,7 +110,7 @@ export function renderOrderSearch( if (abortCtrl) abortCtrl.abort(); abortCtrl = new AbortController(); try { - const result = await searchOrdersByTag( + const result = await searchCommits( options.testsuite, text, { limit: 10 }, abortCtrl.signal, ); dropdown.replaceChildren(); @@ -118,14 +119,16 @@ export function renderOrderSearch( wrapper.setAttribute('aria-expanded', 'false'); return; } - for (const order of result.items) { - const pv = primaryOrderValue(order.fields); + for (const item of result.items) { const li = el('li', { class: 'combobox-item', tabindex: '-1' }); - li.append(el('span', {}, pv)); - if (order.tag) { - li.append(el('span', { class: 'order-search-tag' }, ` (${order.tag})`)); + li.append(el('span', {}, item.commit)); + const display = commitDisplayValue(item.commit, item.fields, options.commitFields); + if (display !== item.commit) { + li.append(el('span', { class: 'commit-search-field' }, ` (${display})`)); + } else if (item.ordinal != null) { + li.append(el('span', { class: 'commit-search-field' }, ` #${item.ordinal}`)); } - li.addEventListener('click', () => selectOrder(pv)); + li.addEventListener('click', () => selectCommit(item.commit)); dropdown.append(li); } dropdown.classList.add('open'); @@ -135,24 +138,24 @@ export function renderOrderSearch( } }, 300); - function isValidOrder(value: string): boolean { + function isValidCommit(value: string): boolean { if (!useSuggestionsMode) return true; - return suggestions.some(s => s.orderValue === value); + return suggestions.some(s => s.commit === value); } function updateValidationState(): void { const text = input.value.trim(); if (!text || !useSuggestionsMode) { - input.classList.remove('order-search-invalid'); + input.classList.remove('commit-search-invalid'); } else { // Only show invalid when there are no partial matches (dropdown is empty) const hasMatches = suggestions.some(s => - s.orderValue.toLowerCase().startsWith(text.toLowerCase()) || - (s.tag && s.tag.toLowerCase().startsWith(text.toLowerCase()))); + s.commit.toLowerCase().startsWith(text.toLowerCase()) || + Object.values(s.fields).some(v => v.toLowerCase().startsWith(text.toLowerCase()))); if (hasMatches) { - input.classList.remove('order-search-invalid'); + input.classList.remove('commit-search-invalid'); } else { - input.classList.add('order-search-invalid'); + input.classList.add('commit-search-invalid'); } } } @@ -180,7 +183,7 @@ export function renderOrderSearch( } else if (e.key === 'Enter') { e.preventDefault(); const text = input.value.trim(); - if (text && isValidOrder(text)) selectOrder(text); + if (text && isValidCommit(text)) selectCommit(text); } else if (e.key === 'Escape') { dropdown.classList.remove('open'); wrapper.setAttribute('aria-expanded', 'false'); @@ -222,7 +225,7 @@ export function renderOrderSearch( document.removeEventListener('click', onDocClick); if (abortCtrl) abortCtrl.abort(); }, - setSuggestions(s: OrderSuggestion[]) { + setSuggestions(s: CommitSummary[]) { suggestions = s; }, }; diff --git a/lnt/server/ui/v5/frontend/src/style.css b/lnt/server/ui/v5/frontend/src/style.css index f9c8d0697..0579edf44 100644 --- a/lnt/server/ui/v5/frontend/src/style.css +++ b/lnt/server/ui/v5/frontend/src/style.css @@ -821,17 +821,17 @@ dl { color: #fff; } -/* Order search */ -.order-search { +/* Commit search */ +.commit-search { position: relative; display: inline-block; } -.order-search-input { +.commit-search-input { width: 280px; } -.order-search-dropdown { +.commit-search-dropdown { position: absolute; z-index: 1000; width: 100%; @@ -848,17 +848,17 @@ dl { box-shadow: 0 2px 8px rgba(0,0,0,0.15); } -.order-search-dropdown.open { +.commit-search-dropdown.open { display: block; } -.order-search-tag { +.commit-search-field { color: #0d6efd; font-size: 12px; margin-left: 4px; } -.order-search-invalid { +.commit-search-invalid { border-color: #d62728 !important; box-shadow: 0 0 0 2px rgba(214, 39, 40, 0.15) !important; } From e0d33d3b35c1733a6b8d45c58116450b3674a22f Mon Sep 17 00:00:00 2001 From: Louis Dionne Date: Tue, 14 Apr 2026 16:26:57 -0400 Subject: [PATCH 056/143] [UI] Rebase Run Detail and Machine Detail pages from Order to Commit Update both pages to use commit string instead of order dict, submitted_at instead of start_time/end_time, and /commits/ links instead of /orders/. Fix run_parameters field name and sort param to match the v5 API. Co-Authored-By: Claude Opus 4.6 (1M context) --- .../__tests__/pages/machine-detail.test.ts | 12 +++++----- .../src/__tests__/pages/run-detail.test.ts | 24 +++++++++---------- .../v5/frontend/src/pages/machine-detail.ts | 16 ++++++------- .../ui/v5/frontend/src/pages/run-detail.ts | 16 ++++++------- 4 files changed, 31 insertions(+), 37 deletions(-) diff --git a/lnt/server/ui/v5/frontend/src/__tests__/pages/machine-detail.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/pages/machine-detail.test.ts index b2d8ff980..df97cdb4e 100644 --- a/lnt/server/ui/v5/frontend/src/__tests__/pages/machine-detail.test.ts +++ b/lnt/server/ui/v5/frontend/src/__tests__/pages/machine-detail.test.ts @@ -41,8 +41,8 @@ const mockMachine: MachineInfo = { }; const mockRuns: MachineRunInfo[] = [ - { uuid: 'aaaaaaaa-1111-2222-3333-444444444444', order: { rev: '100' }, start_time: '2026-01-01T10:00:00Z', end_time: null }, - { uuid: 'bbbbbbbb-1111-2222-3333-444444444444', order: { rev: '101' }, start_time: '2026-01-02T10:00:00Z', end_time: null }, + { uuid: 'aaaaaaaa-1111-2222-3333-444444444444', commit: '100', submitted_at: '2026-01-01T10:00:00Z' }, + { uuid: 'bbbbbbbb-1111-2222-3333-444444444444', commit: '101', submitted_at: '2026-01-02T10:00:00Z' }, ]; function runsResponse(items: MachineRunInfo[], nextCursor: string | null = null) { @@ -139,19 +139,19 @@ describe('machineDetailPage', () => { expect(getMachineRuns).toHaveBeenCalledWith( 'nts', 'clang-x86', - { sort: '-start_time', limit: 25, cursor: undefined }, + { sort: '-submitted_at', limit: 25, cursor: undefined }, expect.any(AbortSignal), ); }); - it('renders run history table with UUID, Order, Start Time columns', async () => { + it('renders run history table with UUID, Commit, Submitted columns', async () => { machineDetailPage.mount(container, { testsuite: 'nts', name: 'clang-x86' }); await vi.waitFor(() => { const headers = Array.from(container.querySelectorAll('th')).map(h => h.textContent); expect(headers).toContain('Run UUID'); - expect(headers).toContain('Order'); - expect(headers).toContain('Start Time'); + expect(headers).toContain('Commit'); + expect(headers).toContain('Submitted'); }); }); diff --git a/lnt/server/ui/v5/frontend/src/__tests__/pages/run-detail.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/pages/run-detail.test.ts index 862995faa..63bb00aef 100644 --- a/lnt/server/ui/v5/frontend/src/__tests__/pages/run-detail.test.ts +++ b/lnt/server/ui/v5/frontend/src/__tests__/pages/run-detail.test.ts @@ -42,10 +42,9 @@ const TEST_UUID = 'abcdef01-2345-6789-abcd-ef0123456789'; const mockRun: RunDetail = { uuid: TEST_UUID, machine: 'clang-x86', - order: { rev: '100' }, - start_time: '2026-01-01T10:00:00Z', - end_time: '2026-01-01T11:00:00Z', - parameters: { compiler: 'clang-18', opt_level: '-O2' }, + commit: '100', + submitted_at: '2026-01-01T10:00:00Z', + run_parameters: { compiler: 'clang-18', opt_level: '-O2' }, }; const mockFields: FieldInfo[] = [ @@ -94,7 +93,7 @@ describe('runDetailPage', () => { expect(getFields).toHaveBeenCalledWith('nts'); }); - it('renders metadata with UUID, Machine, Order, Start Time, End Time, parameters', async () => { + it('renders metadata with UUID, Machine, Commit, Submitted, parameters', async () => { runDetailPage.mount(container, { testsuite: 'nts', uuid: TEST_UUID }); await vi.waitFor(() => { @@ -103,9 +102,8 @@ describe('runDetailPage', () => { expect(dl!.textContent).toContain('UUID'); expect(dl!.textContent).toContain(TEST_UUID); expect(dl!.textContent).toContain('Machine'); - expect(dl!.textContent).toContain('Order'); - expect(dl!.textContent).toContain('Start Time'); - expect(dl!.textContent).toContain('End Time'); + expect(dl!.textContent).toContain('Commit'); + expect(dl!.textContent).toContain('Submitted'); expect(dl!.textContent).toContain('compiler'); expect(dl!.textContent).toContain('clang-18'); expect(dl!.textContent).toContain('opt_level'); @@ -113,7 +111,7 @@ describe('runDetailPage', () => { }); }); - it('Machine and Order render as SPA links with suite-scoped hrefs', async () => { + it('Machine and Commit render as SPA links with suite-scoped hrefs', async () => { runDetailPage.mount(container, { testsuite: 'nts', uuid: TEST_UUID }); await vi.waitFor(() => { @@ -122,9 +120,9 @@ describe('runDetailPage', () => { expect(machineLink.textContent).toBe('clang-x86'); expect(machineLink.href).toContain('/v5/nts/machines/clang-x86'); - const orderLink = container.querySelector('a[href*="/orders/100"]') as HTMLAnchorElement; - expect(orderLink).toBeTruthy(); - expect(orderLink.href).toContain('/v5/nts/orders/100'); + const commitLink = container.querySelector('a[href*="/commits/100"]') as HTMLAnchorElement; + expect(commitLink).toBeTruthy(); + expect(commitLink.href).toContain('/v5/nts/commits/100'); }); }); @@ -142,7 +140,7 @@ describe('runDetailPage', () => { // Must include suite_a param expect(href).toContain('suite_a=nts'); expect(href).toContain('machine_a=clang-x86'); - expect(href).toContain('order_a=100'); + expect(href).toContain('commit_a=100'); expect(href).toContain(`runs_a=${encodeURIComponent(TEST_UUID)}`); }); }); diff --git a/lnt/server/ui/v5/frontend/src/pages/machine-detail.ts b/lnt/server/ui/v5/frontend/src/pages/machine-detail.ts index 4db7520e2..0cc169d39 100644 --- a/lnt/server/ui/v5/frontend/src/pages/machine-detail.ts +++ b/lnt/server/ui/v5/frontend/src/pages/machine-detail.ts @@ -3,7 +3,7 @@ import type { PageModule, RouteParams } from '../router'; import type { MachineRunInfo } from '../types'; import { getMachine, getMachineRuns, deleteMachine } from '../api'; -import { el, spaLink, agnosticLink, agnosticUrl, formatTime, truncate, primaryOrderValue } from '../utils'; +import { el, spaLink, agnosticLink, agnosticUrl, formatTime, truncate } from '../utils'; import { renderDataTable } from '../components/data-table'; import { renderPagination } from '../components/pagination'; import { renderDeleteConfirm } from '../components/delete-confirm'; @@ -63,7 +63,7 @@ export const machineDetailPage: PageModule = { try { const result = await getMachineRuns(ts, name, { - sort: '-start_time', + sort: '-submitted_at', limit: PAGE_SIZE, cursor: currentCursor, }, signal); @@ -76,13 +76,11 @@ export const machineDetailPage: PageModule = { columns: [ { key: 'uuid', label: 'Run UUID', render: (r: MachineRunInfo) => spaLink(r.uuid.slice(0, 8), `/runs/${encodeURIComponent(r.uuid)}`) }, - { key: 'order', label: 'Order', - render: (r: MachineRunInfo) => { - const ov = primaryOrderValue(r.order); - return spaLink(truncate(ov, 12), `/orders/${encodeURIComponent(ov)}`); - } }, - { key: 'start_time', label: 'Start Time', - render: (r: MachineRunInfo) => formatTime(r.start_time) }, + { key: 'commit', label: 'Commit', + render: (r: MachineRunInfo) => + spaLink(truncate(r.commit, 12), `/commits/${encodeURIComponent(r.commit)}`) }, + { key: 'submitted_at', label: 'Submitted', + render: (r: MachineRunInfo) => formatTime(r.submitted_at) }, ], rows: result.items, emptyMessage: 'No runs found.', diff --git a/lnt/server/ui/v5/frontend/src/pages/run-detail.ts b/lnt/server/ui/v5/frontend/src/pages/run-detail.ts index 0dbc763eb..811208e65 100644 --- a/lnt/server/ui/v5/frontend/src/pages/run-detail.ts +++ b/lnt/server/ui/v5/frontend/src/pages/run-detail.ts @@ -4,7 +4,7 @@ import type { PageModule, RouteParams } from '../router'; import type { SampleInfo } from '../types'; import { getRun, getFields, deleteRun, fetchOneCursorPage, apiUrl } from '../api'; -import { el, spaLink, agnosticLink, formatValue, formatTime, primaryOrderValue, debounce } from '../utils'; +import { el, spaLink, agnosticLink, formatValue, formatTime, debounce } from '../utils'; import { navigate } from '../router'; import { renderDataTable } from '../components/data-table'; import { renderMetricSelector, filterMetricFields } from '../components/metric-selector'; @@ -59,15 +59,13 @@ export const runDetailPage: PageModule = { machineDd.append(spaLink(run.machine, `/machines/${encodeURIComponent(run.machine)}`)); dl.append(el('dt', {}, 'Machine'), machineDd); - const orderValue = primaryOrderValue(run.order); - const orderDd = el('dd', {}); - orderDd.append(spaLink(orderValue, `/orders/${encodeURIComponent(orderValue)}`)); - dl.append(el('dt', {}, 'Order'), orderDd); + const commitDd = el('dd', {}); + commitDd.append(spaLink(run.commit, `/commits/${encodeURIComponent(run.commit)}`)); + dl.append(el('dt', {}, 'Commit'), commitDd); - dl.append(el('dt', {}, 'Start Time'), el('dd', {}, formatTime(run.start_time))); - dl.append(el('dt', {}, 'End Time'), el('dd', {}, formatTime(run.end_time))); + dl.append(el('dt', {}, 'Submitted'), el('dd', {}, formatTime(run.submitted_at))); - for (const [k, v] of Object.entries(run.parameters || {})) { + for (const [k, v] of Object.entries(run.run_parameters || {})) { dl.append(el('dt', {}, k), el('dd', {}, v)); } metaContainer.append(dl); @@ -75,7 +73,7 @@ export const runDetailPage: PageModule = { // Actions const compareLink = agnosticLink( 'Compare with\u2026', - `/compare?suite_a=${encodeURIComponent(ts)}&machine_a=${encodeURIComponent(run.machine)}&order_a=${encodeURIComponent(orderValue)}&runs_a=${encodeURIComponent(uuid)}`, + `/compare?suite_a=${encodeURIComponent(ts)}&machine_a=${encodeURIComponent(run.machine)}&commit_a=${encodeURIComponent(run.commit)}&runs_a=${encodeURIComponent(uuid)}`, ); compareLink.classList.add('action-link'); actionsContainer.append(compareLink); From 91e0aa1e1ba22c0fc279166fda14abb25d79db12 Mon Sep 17 00:00:00 2001 From: Louis Dionne Date: Tue, 14 Apr 2026 17:10:48 -0400 Subject: [PATCH 057/143] [UI] Rebase Graph page, data cache and chart from Order to Commit Update graph.ts, graph-data-cache.ts and time-series-chart.ts to use the Commit model: order dicts become commit strings, tags removed from baselines, timestamp renamed to submitted_at, primaryOrderValue calls replaced with direct commit access. Fix scaffold sort param from the silently-ignored 'order' to 'submitted_at'. All 658 JS tests pass. Co-Authored-By: Claude Opus 4.6 (1M context) --- .../__tests__/pages/graph-data-cache.test.ts | 33 ++-- .../src/__tests__/pages/graph.test.ts | 74 ++++---- .../src/__tests__/time-series-chart.test.ts | 86 +++++----- .../src/components/time-series-chart.ts | 41 +++-- .../v5/frontend/src/pages/graph-data-cache.ts | 31 ++-- lnt/server/ui/v5/frontend/src/pages/graph.ts | 159 +++++++++--------- 6 files changed, 202 insertions(+), 222 deletions(-) diff --git a/lnt/server/ui/v5/frontend/src/__tests__/pages/graph-data-cache.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/pages/graph-data-cache.test.ts index 815274823..47a978332 100644 --- a/lnt/server/ui/v5/frontend/src/__tests__/pages/graph-data-cache.test.ts +++ b/lnt/server/ui/v5/frontend/src/__tests__/pages/graph-data-cache.test.ts @@ -9,9 +9,10 @@ function makePoint(test: string, orderValue: string, value: number, machine = 'm machine, metric, value, - order: { rev: orderValue }, + commit: orderValue, + ordinal: null, run_uuid: 'r1', - timestamp: null, + submitted_at: null, }; } @@ -40,11 +41,11 @@ describe('GraphDataCache', () => { // ------------------------------------------------------------------------- describe('getScaffold', () => { - it('fetches and caches scaffold orders', async () => { + it('fetches and caches scaffold commits', async () => { api.fetchOneCursorPage.mockResolvedValueOnce({ items: [ - { uuid: 'r1', order: { rev: '100' }, start_time: null, end_time: null }, - { uuid: 'r2', order: { rev: '101' }, start_time: null, end_time: null }, + { uuid: 'r1', commit: '100', submitted_at: null }, + { uuid: 'r2', commit: '101', submitted_at: null }, ], nextCursor: null, }); @@ -62,11 +63,11 @@ describe('GraphDataCache', () => { it('paginates through all results', async () => { api.fetchOneCursorPage .mockResolvedValueOnce({ - items: [{ uuid: 'r1', order: { rev: '100' }, start_time: null, end_time: null }], + items: [{ uuid: 'r1', commit: '100', submitted_at: null }], nextCursor: 'cursor1', }) .mockResolvedValueOnce({ - items: [{ uuid: 'r2', order: { rev: '101' }, start_time: null, end_time: null }], + items: [{ uuid: 'r2', commit: '101', submitted_at: null }], nextCursor: null, }); @@ -75,12 +76,12 @@ describe('GraphDataCache', () => { expect(api.fetchOneCursorPage).toHaveBeenCalledTimes(2); }); - it('deduplicates order values', async () => { + it('deduplicates commit values', async () => { api.fetchOneCursorPage.mockResolvedValueOnce({ items: [ - { uuid: 'r1', order: { rev: '100' }, start_time: null, end_time: null }, - { uuid: 'r2', order: { rev: '100' }, start_time: null, end_time: null }, - { uuid: 'r3', order: { rev: '101' }, start_time: null, end_time: null }, + { uuid: 'r1', commit: '100', submitted_at: null }, + { uuid: 'r2', commit: '100', submitted_at: null }, + { uuid: 'r3', commit: '101', submitted_at: null }, ], nextCursor: null, }); @@ -356,15 +357,15 @@ describe('GraphDataCache', () => { api.fetchOneCursorPage .mockResolvedValueOnce({ items: [ - { uuid: 'r1', order: { rev: '100' }, start_time: null, end_time: null }, - { uuid: 'r2', order: { rev: '101' }, start_time: null, end_time: null }, + { uuid: 'r1', commit: '100', submitted_at: null }, + { uuid: 'r2', commit: '101', submitted_at: null }, ], nextCursor: null, }) .mockResolvedValueOnce({ items: [ - { uuid: 'r3', order: { rev: '101' }, start_time: null, end_time: null }, - { uuid: 'r4', order: { rev: '102' }, start_time: null, end_time: null }, + { uuid: 'r3', commit: '101', submitted_at: null }, + { uuid: 'r4', commit: '102', submitted_at: null }, ], nextCursor: null, }); @@ -390,7 +391,7 @@ describe('GraphDataCache', () => { // Populate each cache type api.fetchOneCursorPage .mockResolvedValueOnce({ - items: [{ uuid: 'r1', order: { rev: '100' }, start_time: null, end_time: null }], + items: [{ uuid: 'r1', commit: '100', submitted_at: null }], nextCursor: null, }) .mockResolvedValueOnce({ diff --git a/lnt/server/ui/v5/frontend/src/__tests__/pages/graph.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/pages/graph.test.ts index ec027f03a..3fa39f7a4 100644 --- a/lnt/server/ui/v5/frontend/src/__tests__/pages/graph.test.ts +++ b/lnt/server/ui/v5/frontend/src/__tests__/pages/graph.test.ts @@ -8,7 +8,7 @@ vi.mock('../../api', async (importOriginal) => { return { ...actual, getFields: vi.fn(), - getOrders: vi.fn().mockResolvedValue([]), + getCommits: vi.fn().mockResolvedValue([]), fetchOneCursorPage: vi.fn(), postOneCursorPage: vi.fn(), apiUrl: vi.fn((suite: string, path: string) => `/api/v5/${suite}/${path}`), @@ -72,9 +72,10 @@ function makePoint(test: string, orderValue: string, value: number, runUuid = 'r machine: 'm1', metric: 'exec_time', value, - order: { rev: orderValue }, + commit: orderValue, + ordinal: null, run_uuid: runUuid, - timestamp: null, + submitted_at: null, }; } @@ -107,7 +108,7 @@ describe('buildTraces', () => { expect(traces[0].testName).toBe('compile/test-A'); }); - it('aggregates multiple runs at same order using run aggregation', () => { + it('aggregates multiple runs at same commit using run aggregation', () => { const points = [ makePoint('test-A', '100', 1.0, 'r1'), makePoint('test-A', '100', 3.0, 'r2'), @@ -215,7 +216,7 @@ describe('buildTraces', () => { expect(traces.map(t => t.testName)).toEqual(['alpha', 'middle', 'zebra']); }); - it('preserves order value across aggregation', () => { + it('preserves commit value across aggregation', () => { const points = [ makePoint('test-A', '100', 1.0), makePoint('test-A', '101', 2.0), @@ -223,7 +224,7 @@ describe('buildTraces', () => { ]; const traces = buildTraces(points, 'median', 'median'); - const orderValues = traces[0].points.map(p => p.orderValue); + const orderValues = traces[0].points.map(p => p.commit); expect(orderValues).toEqual(['100', '101', '102']); }); @@ -236,7 +237,7 @@ describe('buildTraces', () => { const traces = buildTraces(points, 'median', 'median'); // buildTraces preserves Map insertion order, so reversed input stays reversed - const orderValues = traces[0].points.map(p => p.orderValue); + const orderValues = traces[0].points.map(p => p.commit); expect(orderValues).toEqual(['102', '101', '100']); }); @@ -254,9 +255,9 @@ describe('buildTraces', () => { expect(traces).toHaveLength(2); // test-A comes first alphabetically expect(traces[0].testName).toBe('test-A'); - expect(traces[0].points.map(p => p.orderValue)).toEqual(['102', '101', '100']); + expect(traces[0].points.map(p => p.commit)).toEqual(['102', '101', '100']); expect(traces[1].testName).toBe('test-B'); - expect(traces[1].points.map(p => p.orderValue)).toEqual(['102', '101', '100']); + expect(traces[1].points.map(p => p.commit)).toEqual(['102', '101', '100']); }); }); @@ -267,9 +268,10 @@ describe('buildBaselinesFromData', () => { machine, metric: 'exec_time', value, - order: { rev: orderValue }, + commit: orderValue, + ordinal: null, run_uuid: 'r1', - timestamp: null, + submitted_at: null, }; } @@ -286,21 +288,21 @@ describe('buildBaselinesFromData', () => { /** Helper to build a lookup function from a list of points for a given baseline. */ function buildLookup( - baselines: Array<{ suite: string; machine: string; order: string; tag: string | null }>, + baselines: Array<{ suite: string; machine: string; commit: string }>, metric: string, pointsPerBaseline: QueryDataPoint[][], - ): (suite: string, machine: string, order: string, met: string) => QueryDataPoint[] { + ): (suite: string, machine: string, commit: string, met: string) => QueryDataPoint[] { const cache = new Map(); for (let i = 0; i < baselines.length; i++) { const bl = baselines[i]; - const key = `${bl.suite}::${bl.machine}::${bl.order}::${metric}`; + const key = `${bl.suite}::${bl.machine}::${bl.commit}::${metric}`; cache.set(key, pointsPerBaseline[i] || []); } return (s, m, o, met) => cache.get(`${s}::${m}::${o}::${met}`) ?? []; } - it('aggregates multiple runs at baseline order using the provided agg function', () => { - const baselines = [{ suite: 'nts', machine: 'm1', order: '100', tag: null }]; + it('aggregates multiple runs at baseline commit using the provided agg function', () => { + const baselines = [{ suite: 'nts', machine: 'm1', commit: '100' }]; const points = [ makeRefPoint('test-A', '100', 1.0), makeRefPoint('test-A', '100', 3.0), @@ -315,7 +317,7 @@ describe('buildBaselinesFromData', () => { }); it('uses the same agg as buildTraces (consistency check)', () => { - const baselines = [{ suite: 'nts', machine: 'm1', order: '100', tag: null }]; + const baselines = [{ suite: 'nts', machine: 'm1', commit: '100' }]; const points = [ makeRefPoint('test-A', '100', 1.0), makeRefPoint('test-A', '100', 3.0), @@ -326,14 +328,14 @@ describe('buildBaselinesFromData', () => { const blResult = buildBaselinesFromData(baselines, cache, 'exec_time', median); const traces = buildTraces(points, 'median', 'median'); - // Both should produce exactly the same value for test-A at order 100 + // Both should produce exactly the same value for test-A at commit 100 const traceValue = traces.find(t => t.testName === 'test-A')!.points - .find(p => p.orderValue === '100')!.value; + .find(p => p.commit === '100')!.value; expect(blResult[0].values.get('test-A')).toBe(traceValue); }); it('uses mean aggregation when provided', () => { - const baselines = [{ suite: 'nts', machine: 'm1', order: '100', tag: null }]; + const baselines = [{ suite: 'nts', machine: 'm1', commit: '100' }]; const points = [ makeRefPoint('test-A', '100', 1.0), makeRefPoint('test-A', '100', 3.0), @@ -346,7 +348,7 @@ describe('buildBaselinesFromData', () => { }); it('handles single data point (no aggregation needed)', () => { - const baselines = [{ suite: 'nts', machine: 'm1', order: '100', tag: null }]; + const baselines = [{ suite: 'nts', machine: 'm1', commit: '100' }]; const points = [makeRefPoint('test-A', '100', 42.0)]; const cache = buildLookup(baselines, 'exec_time', [points]); @@ -355,8 +357,8 @@ describe('buildBaselinesFromData', () => { expect(result[0].values.get('test-A')).toBe(42.0); }); - it('handles multiple tests at the same baseline order', () => { - const baselines = [{ suite: 'nts', machine: 'm1', order: '100', tag: null }]; + it('handles multiple tests at the same baseline commit', () => { + const baselines = [{ suite: 'nts', machine: 'm1', commit: '100' }]; const points = [ makeRefPoint('test-A', '100', 1.0), makeRefPoint('test-A', '100', 3.0), @@ -373,8 +375,8 @@ describe('buildBaselinesFromData', () => { it('handles multiple baselines', () => { const baselines = [ - { suite: 'nts', machine: 'm1', order: '100', tag: 'v1' }, - { suite: 'nts', machine: 'm1', order: '101', tag: null }, + { suite: 'nts', machine: 'm1', commit: '100' }, + { suite: 'nts', machine: 'm1', commit: '101' }, ]; const points1 = [makeRefPoint('test-A', '100', 1.0)]; const points2 = [makeRefPoint('test-A', '101', 5.0)]; @@ -384,15 +386,13 @@ describe('buildBaselinesFromData', () => { expect(result).toHaveLength(2); expect(result[0].values.get('test-A')).toBe(1.0); - expect(result[0].tag).toBe('v1'); expect(result[1].values.get('test-A')).toBe(5.0); - expect(result[1].tag).toBeNull(); }); const emptyLookup = () => [] as QueryDataPoint[]; it('returns empty values map when baseline has no cached data', () => { - const baselines = [{ suite: 'nts', machine: 'm1', order: '999', tag: null }]; + const baselines = [{ suite: 'nts', machine: 'm1', commit: '999' }]; const result = buildBaselinesFromData(baselines, emptyLookup, 'exec_time', median); @@ -407,7 +407,7 @@ describe('buildBaselinesFromData', () => { it('does not include a color field on returned baselines', () => { const baselines = [ - { suite: 'nts', machine: 'm1', order: '100', tag: null }, + { suite: 'nts', machine: 'm1', commit: '100' }, ]; const points1 = [makeRefPoint('test-A', '100', 1.0)]; const cache = buildLookup(baselines, 'exec_time', [points1]); @@ -417,26 +417,18 @@ describe('buildBaselinesFromData', () => { expect(result[0]).not.toHaveProperty('color'); }); - it('builds label with suite/machine/order format', () => { - const baselines = [{ suite: 'nts', machine: 'm1', order: '100', tag: null }]; + it('builds label with suite/machine/commit format', () => { + const baselines = [{ suite: 'nts', machine: 'm1', commit: '100' }]; const result = buildBaselinesFromData(baselines, emptyLookup, 'exec_time', median); expect(result[0].label).toBe('nts/m1/100'); }); - it('includes tag in label when present', () => { - const baselines = [{ suite: 'nts', machine: 'm1', order: '100', tag: 'v1.0' }]; - - const result = buildBaselinesFromData(baselines, emptyLookup, 'exec_time', median); - - expect(result[0].label).toBe('nts/m1/100 (v1.0)'); - }); - it('supports cross-suite baselines', () => { const baselines = [ - { suite: 'nts', machine: 'm1', order: '100', tag: null }, - { suite: 'other-suite', machine: 'm2', order: '200', tag: null }, + { suite: 'nts', machine: 'm1', commit: '100' }, + { suite: 'other-suite', machine: 'm2', commit: '200' }, ]; const points1 = [makeRefPoint('test-A', '100', 1.0)]; const points2 = [makeRefPoint('test-A', '200', 9.0)]; diff --git a/lnt/server/ui/v5/frontend/src/__tests__/time-series-chart.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/time-series-chart.test.ts index 670f7f26e..de71fab76 100644 --- a/lnt/server/ui/v5/frontend/src/__tests__/time-series-chart.test.ts +++ b/lnt/server/ui/v5/frontend/src/__tests__/time-series-chart.test.ts @@ -4,11 +4,11 @@ import { buildPlotlyData, createTimeSeriesChart } from '../components/time-serie import type { TimeSeriesTrace, PinnedBaseline, TimeSeriesChartOptions, ChartHandle } from '../components/time-series-chart'; import { TRACE_SEP } from '../pages/graph'; -function makeTrace(name: string, points: Array<{ orderValue: string; value: number }>, machine = 'm1'): TimeSeriesTrace { +function makeTrace(name: string, points: Array<{ commit: string; value: number }>, machine = 'm1'): TimeSeriesTrace { return { testName: name, machine, - points: points.map(p => ({ ...p, runCount: 1, timestamp: null })), + points: points.map(p => ({ ...p, runCount: 1, submitted_at: null })), }; } @@ -16,8 +16,8 @@ describe('buildPlotlyData', () => { it('builds one Plotly trace per test', () => { const opts: TimeSeriesChartOptions = { traces: [ - makeTrace('test-A', [{ orderValue: '100', value: 1.5 }, { orderValue: '101', value: 2.0 }]), - makeTrace('test-B', [{ orderValue: '100', value: 3.0 }]), + makeTrace('test-A', [{ commit: '100', value: 1.5 }, { commit: '101', value: 2.0 }]), + makeTrace('test-B', [{ commit: '100', value: 3.0 }]), ], yAxisLabel: 'exec_time', }; @@ -32,7 +32,7 @@ describe('buildPlotlyData', () => { it('sets x-axis to category type', () => { const opts: TimeSeriesChartOptions = { - traces: [makeTrace('t', [{ orderValue: '100', value: 1.0 }])], + traces: [makeTrace('t', [{ commit: '100', value: 1.0 }])], yAxisLabel: 'metric', }; @@ -42,13 +42,13 @@ describe('buildPlotlyData', () => { it('includes customdata for hover template', () => { const opts: TimeSeriesChartOptions = { - traces: [makeTrace('test-A', [{ orderValue: '100', value: 1.5 }])], + traces: [makeTrace('test-A', [{ commit: '100', value: 1.5 }])], yAxisLabel: 'metric', }; const { data } = buildPlotlyData(opts); const trace = data[0] as { customdata: string[][] }; - expect(trace.customdata[0][0]).toBe('100'); // orderValue + expect(trace.customdata[0][0]).toBe('100'); // commit expect(trace.customdata[0][1]).toBe(`test-A${TRACE_SEP}m1`); // traceName expect(trace.customdata[0][4]).toBe('test-A'); // testName expect(trace.customdata[0][5]).toBe('m1'); // machine @@ -58,14 +58,13 @@ describe('buildPlotlyData', () => { const refValues = new Map(); refValues.set('test-A', 2.5); - const mainTrace = makeTrace('test-A', [{ orderValue: '100', value: 1.5 }, { orderValue: '102', value: 2.0 }]); + const mainTrace = makeTrace('test-A', [{ commit: '100', value: 1.5 }, { commit: '102', value: 2.0 }]); mainTrace.color = '#1f77b4'; const opts: TimeSeriesChartOptions = { traces: [mainTrace], yAxisLabel: 'metric', baselines: [{ label: '101 (release-18)', - tag: 'release-18', values: refValues, }], }; @@ -93,11 +92,10 @@ describe('buildPlotlyData', () => { refValues.set('', 3.0); const opts: TimeSeriesChartOptions = { - traces: [makeTrace('', [{ orderValue: '100', value: 1.5 }])], + traces: [makeTrace('', [{ commit: '100', value: 1.5 }])], yAxisLabel: 'metric', baselines: [{ label: '101 ()', - tag: '', values: refValues, }], }; @@ -116,12 +114,11 @@ describe('buildPlotlyData', () => { refValues.set('test-A', 2.5); const opts: TimeSeriesChartOptions = { - traces: [makeTrace('test-A', [{ orderValue: '102', value: 1.5 }, { orderValue: '103', value: 2.0 }])], + traces: [makeTrace('test-A', [{ commit: '102', value: 1.5 }, { commit: '103', value: 2.0 }])], yAxisLabel: 'metric', categoryOrder: ['100', '101', '102', '103', '104', '105'], baselines: [{ label: '101', - tag: null, values: refValues, }], }; @@ -138,11 +135,10 @@ describe('buildPlotlyData', () => { refValues.set('nonexistent-test', 5.0); const opts: TimeSeriesChartOptions = { - traces: [makeTrace('test-A', [{ orderValue: '100', value: 1.0 }])], + traces: [makeTrace('test-A', [{ commit: '100', value: 1.0 }])], yAxisLabel: 'metric', baselines: [{ label: '100', - tag: null, values: refValues, }], }; @@ -154,7 +150,7 @@ describe('buildPlotlyData', () => { it('hides legend when only one trace', () => { const opts: TimeSeriesChartOptions = { - traces: [makeTrace('t', [{ orderValue: '100', value: 1.0 }])], + traces: [makeTrace('t', [{ commit: '100', value: 1.0 }])], yAxisLabel: 'metric', }; @@ -164,7 +160,7 @@ describe('buildPlotlyData', () => { it('sets categoryarray when categoryOrder is provided', () => { const opts: TimeSeriesChartOptions = { - traces: [makeTrace('t', [{ orderValue: '102', value: 1.0 }])], + traces: [makeTrace('t', [{ commit: '102', value: 1.0 }])], yAxisLabel: 'metric', categoryOrder: ['100', '101', '102', '103'], }; @@ -177,7 +173,7 @@ describe('buildPlotlyData', () => { it('does not set categoryarray when categoryOrder is omitted', () => { const opts: TimeSeriesChartOptions = { - traces: [makeTrace('t', [{ orderValue: '100', value: 1.0 }])], + traces: [makeTrace('t', [{ commit: '100', value: 1.0 }])], yAxisLabel: 'metric', }; @@ -190,8 +186,8 @@ describe('buildPlotlyData', () => { it('always hides built-in legend (replaced by test-selection table)', () => { const opts: TimeSeriesChartOptions = { traces: [ - makeTrace('t1', [{ orderValue: '100', value: 1.0 }]), - makeTrace('t2', [{ orderValue: '100', value: 2.0 }]), + makeTrace('t1', [{ commit: '100', value: 1.0 }]), + makeTrace('t2', [{ commit: '100', value: 2.0 }]), ], yAxisLabel: 'metric', }; @@ -245,7 +241,7 @@ describe('createTimeSeriesChart', () => { it('calls Plotly.newPlot on creation', () => { const container = document.createElement('div'); createTimeSeriesChart(container, { - traces: [makeTrace('t1', [{ orderValue: '100', value: 1.0 }])], + traces: [makeTrace('t1', [{ commit: '100', value: 1.0 }])], yAxisLabel: 'metric', }); @@ -256,12 +252,12 @@ describe('createTimeSeriesChart', () => { it('calls Plotly.react on update()', async () => { const container = document.createElement('div'); const handle = createTimeSeriesChart(container, { - traces: [makeTrace('t1', [{ orderValue: '100', value: 1.0 }])], + traces: [makeTrace('t1', [{ commit: '100', value: 1.0 }])], yAxisLabel: 'metric', }); handle.update({ - traces: [makeTrace('t1', [{ orderValue: '100', value: 2.0 }])], + traces: [makeTrace('t1', [{ commit: '100', value: 2.0 }])], yAxisLabel: 'metric', }); @@ -275,7 +271,7 @@ describe('createTimeSeriesChart', () => { it('calls Plotly.purge on destroy()', () => { const container = document.createElement('div'); const handle = createTimeSeriesChart(container, { - traces: [makeTrace('t1', [{ orderValue: '100', value: 1.0 }])], + traces: [makeTrace('t1', [{ commit: '100', value: 1.0 }])], yAxisLabel: 'metric', }); @@ -303,7 +299,7 @@ describe('createTimeSeriesChart', () => { }); handle.update({ - traces: [makeTrace('t1', [{ orderValue: '100', value: 1.0 }])], + traces: [makeTrace('t1', [{ commit: '100', value: 1.0 }])], yAxisLabel: 'metric', }); @@ -326,13 +322,13 @@ describe('createTimeSeriesChart', () => { }); const handle = createTimeSeriesChart(container, { - traces: [makeTrace('t1', [{ orderValue: '100', value: 1.0 }])], + traces: [makeTrace('t1', [{ commit: '100', value: 1.0 }])], yAxisLabel: 'metric', categoryOrder: ['100', '101', '102'], }); handle.update({ - traces: [makeTrace('t1', [{ orderValue: '100', value: 2.0 }, { orderValue: '101', value: 3.0 }])], + traces: [makeTrace('t1', [{ commit: '100', value: 2.0 }, { commit: '101', value: 3.0 }])], yAxisLabel: 'metric', categoryOrder: ['100', '101', '102'], }); @@ -359,12 +355,12 @@ describe('createTimeSeriesChart', () => { }); const handle = createTimeSeriesChart(container, { - traces: [makeTrace('t1', [{ orderValue: '100', value: 1.0 }])], + traces: [makeTrace('t1', [{ commit: '100', value: 1.0 }])], yAxisLabel: 'metric', }); handle.update({ - traces: [makeTrace('t1', [{ orderValue: '100', value: 2.0 }])], + traces: [makeTrace('t1', [{ commit: '100', value: 2.0 }])], yAxisLabel: 'metric', }); @@ -389,12 +385,12 @@ describe('createTimeSeriesChart', () => { }); const handle = createTimeSeriesChart(container, { - traces: [makeTrace('t1', [{ orderValue: '100', value: 1.0 }])], + traces: [makeTrace('t1', [{ commit: '100', value: 1.0 }])], yAxisLabel: 'metric', }); handle.update({ - traces: [makeTrace('t1', [{ orderValue: '100', value: 2.0 }])], + traces: [makeTrace('t1', [{ commit: '100', value: 2.0 }])], yAxisLabel: 'metric', }); @@ -421,13 +417,13 @@ describe('createTimeSeriesChart', () => { }); const handle = createTimeSeriesChart(container, { - traces: [makeTrace('t1', [{ orderValue: '100', value: 1.0 }])], + traces: [makeTrace('t1', [{ commit: '100', value: 1.0 }])], yAxisLabel: 'metric', categoryOrder: ['100', '101', '102'], }); handle.update({ - traces: [makeTrace('t1', [{ orderValue: '100', value: 2.0 }])], + traces: [makeTrace('t1', [{ commit: '100', value: 2.0 }])], yAxisLabel: 'metric', categoryOrder: ['100', '101', '102'], }); @@ -449,9 +445,9 @@ describe('createTimeSeriesChart', () => { const container = document.createElement('div'); const handle = createTimeSeriesChart(container, { traces: [ - makeTrace('test-A', [{ orderValue: '100', value: 1.0 }]), - makeTrace('test-B', [{ orderValue: '100', value: 2.0 }]), - makeTrace('test-C', [{ orderValue: '100', value: 3.0 }]), + makeTrace('test-A', [{ commit: '100', value: 1.0 }]), + makeTrace('test-B', [{ commit: '100', value: 2.0 }]), + makeTrace('test-C', [{ commit: '100', value: 3.0 }]), ], yAxisLabel: 'metric', }); @@ -475,8 +471,8 @@ describe('createTimeSeriesChart', () => { const container = document.createElement('div'); const handle = createTimeSeriesChart(container, { traces: [ - makeTrace('test-A', [{ orderValue: '100', value: 1.0 }]), - makeTrace('test-B', [{ orderValue: '100', value: 2.0 }]), + makeTrace('test-A', [{ commit: '100', value: 1.0 }]), + makeTrace('test-B', [{ commit: '100', value: 2.0 }]), ], yAxisLabel: 'metric', }); @@ -498,12 +494,12 @@ describe('createTimeSeriesChart', () => { const handle = createTimeSeriesChart(container, { traces: [ - makeTrace('test-A', [{ orderValue: '100', value: 1.0 }]), - makeTrace('test-B', [{ orderValue: '100', value: 2.0 }]), + makeTrace('test-A', [{ commit: '100', value: 1.0 }]), + makeTrace('test-B', [{ commit: '100', value: 2.0 }]), ], yAxisLabel: 'metric', baselines: [{ - label: '100', tag: null, values: refValues, + label: '100', values: refValues, }], }); @@ -532,7 +528,7 @@ describe('createTimeSeriesChart', () => { createTimeSeriesChart(container, { traces: [ - { testName: 'test-A', machine: 'm1', color: '#1f77b4', points: [{ orderValue: '100', value: 2.0, runCount: 3, timestamp: null }] }, + { testName: 'test-A', machine: 'm1', color: '#1f77b4', points: [{ commit: '100', value: 2.0, runCount: 3, submitted_at: null }] }, ], yAxisLabel: 'metric', getRawValues: (_test, _machine, _order) => [1.0, 2.0, 3.0], @@ -568,7 +564,7 @@ describe('createTimeSeriesChart', () => { createTimeSeriesChart(container, { traces: [ - { testName: 'test-A', machine: 'm1', color: '#1f77b4', points: [{ orderValue: '100', value: 1.0, runCount: 1, timestamp: null }] }, + { testName: 'test-A', machine: 'm1', color: '#1f77b4', points: [{ commit: '100', value: 1.0, runCount: 1, submitted_at: null }] }, ], yAxisLabel: 'metric', getRawValues: () => [1.0], @@ -593,7 +589,7 @@ describe('createTimeSeriesChart', () => { createTimeSeriesChart(container, { traces: [ - { testName: 'test-A', machine: 'm1', color: '#1f77b4', points: [{ orderValue: '100', value: 2.0, runCount: 3, timestamp: null }] }, + { testName: 'test-A', machine: 'm1', color: '#1f77b4', points: [{ commit: '100', value: 2.0, runCount: 3, submitted_at: null }] }, ], yAxisLabel: 'metric', getRawValues: () => [1.0, 2.0, 3.0], @@ -624,7 +620,7 @@ describe('createTimeSeriesChart', () => { createTimeSeriesChart(container, { traces: [ - { testName: 'test-A', machine: 'm1', color: '#1f77b4', points: [{ orderValue: '100', value: 2.0, runCount: 3, timestamp: null }] }, + { testName: 'test-A', machine: 'm1', color: '#1f77b4', points: [{ commit: '100', value: 2.0, runCount: 3, submitted_at: null }] }, ], yAxisLabel: 'metric', // no getRawValues diff --git a/lnt/server/ui/v5/frontend/src/components/time-series-chart.ts b/lnt/server/ui/v5/frontend/src/components/time-series-chart.ts index 6d41c4f4a..7775ec0a0 100644 --- a/lnt/server/ui/v5/frontend/src/components/time-series-chart.ts +++ b/lnt/server/ui/v5/frontend/src/components/time-series-chart.ts @@ -31,17 +31,16 @@ export interface TimeSeriesTrace { /** Plotly marker symbol (e.g., 'circle', 'triangle-up', 'square'). */ markerSymbol?: string; points: Array<{ - orderValue: string; + commit: string; value: number; runCount: number; - timestamp: string | null; + submitted_at: string | null; }>; } export interface PinnedBaseline { - /** Display label, e.g. "libstdc++/gcc-x86/v13.2" or with " (tag)". */ + /** Display label, e.g. "libstdc++/gcc-x86/v13.2". */ label: string; - tag: string | null; /** Per-test values at this baseline. */ values: Map; } @@ -50,14 +49,14 @@ export interface TimeSeriesChartOptions { traces: TimeSeriesTrace[]; yAxisLabel: string; baselines?: PinnedBaseline[]; - onClick?: (orderValue: string) => void; + onClick?: (commit: string) => void; /** Fixed x-axis category order. When set, the x-axis shows exactly these * categories in this order and does not resize as data loads progressively. */ categoryOrder?: string[]; /** Lazy callback to get individual pre-aggregation values for a data point. * Called on hover; if it returns >1 values, a scatter of the raw values * is shown at the hovered x-position. */ - getRawValues?: (testName: string, machine: string, orderValue: string) => number[]; + getRawValues?: (testName: string, machine: string, commit: string) => number[]; } /** @@ -70,24 +69,24 @@ export function buildPlotlyData(options: TimeSeriesChartOptions): { } { const data: unknown[] = []; - // Collect all unique order values across all traces (for consistent x-axis) - const allOrders: string[] = []; - const orderSet = new Set(); + // Collect all unique commit values across all traces (for consistent x-axis) + const allCommits: string[] = []; + const commitSet = new Set(); for (const trace of options.traces) { for (const pt of trace.points) { - if (!orderSet.has(pt.orderValue)) { - orderSet.add(pt.orderValue); - allOrders.push(pt.orderValue); + if (!commitSet.has(pt.commit)) { + commitSet.add(pt.commit); + allCommits.push(pt.commit); } } } for (const trace of options.traces) { - const x = trace.points.map(p => p.orderValue); + const x = trace.points.map(p => p.commit); const y = trace.points.map(p => p.value); const traceName = `${trace.testName}${TRACE_SEP}${trace.machine}`; const customdata = trace.points.map(p => [ - p.orderValue, + p.commit, traceName, p.value.toPrecision(4), String(p.runCount), @@ -111,7 +110,7 @@ export function buildPlotlyData(options: TimeSeriesChartOptions): { hovertemplate: '%{customdata[4]}
    ' + 'Machine: %{customdata[5]}
    ' + - 'Order: %{customdata[0]}
    ' + + 'Commit: %{customdata[0]}
    ' + 'Value: %{customdata[2]}
    ' + 'Runs: %{customdata[3]}', }; @@ -124,7 +123,7 @@ export function buildPlotlyData(options: TimeSeriesChartOptions): { // Each trace is populated with a data point at every x-category so that // hover detection works anywhere along the line (not just at 2 endpoints). if (options.baselines) { - const pinXValues = options.categoryOrder ?? (allOrders.length > 0 ? allOrders : null); + const pinXValues = options.categoryOrder ?? (allCommits.length > 0 ? allCommits : null); if (pinXValues) { for (const ref of options.baselines) { @@ -151,7 +150,7 @@ export function buildPlotlyData(options: TimeSeriesChartOptions): { const xaxis: Record = { type: 'category', - title: 'Order', + title: 'Commit', tickangle: -45, automargin: true, }; @@ -258,10 +257,10 @@ export function createTimeSeriesChart( // Show raw value scatter if getRawValues is available if (!getRawValues || !chartDiv) return; - const orderValue = pt?.customdata?.[0]; + const commitValue = pt?.customdata?.[0]; const testName = pt?.customdata?.[4]; const machineName = pt?.customdata?.[5]; - if (!testName || !machineName || !orderValue) return; + if (!testName || !machineName || !commitValue) return; // Remove any existing scatter trace first plotReady = plotReady.then(() => { @@ -280,12 +279,12 @@ export function createTimeSeriesChart( hasScatterTrace = false; } if (!getRawValues) return; - const rawValues = getRawValues(testName, machineName, orderValue); + const rawValues = getRawValues(testName, machineName, commitValue); if (rawValues.length <= 1) return; const color = traceColorMap.get(`${testName}${TRACE_SEP}${machineName}`) || '#999'; const scatter = { - x: rawValues.map(() => orderValue), + x: rawValues.map(() => commitValue), y: rawValues, mode: 'markers', type: 'scatter', diff --git a/lnt/server/ui/v5/frontend/src/pages/graph-data-cache.ts b/lnt/server/ui/v5/frontend/src/pages/graph-data-cache.ts index ce679dbc6..04379f310 100644 --- a/lnt/server/ui/v5/frontend/src/pages/graph-data-cache.ts +++ b/lnt/server/ui/v5/frontend/src/pages/graph-data-cache.ts @@ -3,7 +3,6 @@ import type { QueryDataPoint } from '../types'; import type { CursorPageResult } from '../api'; import type { MachineRunInfo } from '../types'; -import { primaryOrderValue } from '../utils'; export interface GraphDataApi { apiUrl: (suite: string, path: string) => string; @@ -17,8 +16,8 @@ function dataKey(suite: string, machine: string, metric: string, test: string): return `${suite}::${machine}::${metric}::${test}`; } -function baselineKey(suite: string, machine: string, order: string, metric: string): string { - return `${suite}::${machine}::${order}::${metric}`; +function baselineKey(suite: string, machine: string, commit: string, metric: string): string { + return `${suite}::${machine}::${commit}::${metric}`; } function testNamesKey(suite: string, machine: string, metric: string): string { @@ -46,23 +45,23 @@ export class GraphDataCache { if (cached) return cached; const seen = new Set(); - const orders: string[] = []; + const commits: string[] = []; let cursor: string | undefined; const runsUrl = this.api.apiUrl(suite, `machines/${encodeURIComponent(machine)}/runs`); while (true) { if (signal?.aborted) throw new DOMException('Aborted', 'AbortError'); - const params: Record = { sort: 'order', limit: '10000' }; + const params: Record = { sort: 'submitted_at', limit: '10000' }; if (cursor) params.cursor = cursor; const page = await this.api.fetchOneCursorPage(runsUrl, params, signal); for (const run of page.items) { - const ov = primaryOrderValue(run.order); - if (!seen.has(ov)) { seen.add(ov); orders.push(ov); } + const ov = run.commit; + if (!seen.has(ov)) { seen.add(ov); commits.push(ov); } } if (!page.nextCursor) break; cursor = page.nextCursor; } - this.scaffolds.set(key, orders); - return orders; + this.scaffolds.set(key, commits); + return commits; } async getTestNames(suite: string, machine: string, metric: string, signal?: AbortSignal): Promise { @@ -107,7 +106,7 @@ export class GraphDataCache { machine, metric, test: [test], - sort: 'test,order', + sort: 'test,commit', limit: PAGE_LIMIT, }; if (cursor) body.cursor = cursor; @@ -144,7 +143,7 @@ export class GraphDataCache { machine, metric, test: uncached, - sort: 'test,order', + sort: 'test,commit', limit: PAGE_LIMIT, }; if (cursor) body.cursor = cursor; @@ -173,10 +172,10 @@ export class GraphDataCache { } async getBaselineData( - suite: string, machine: string, order: string, metric: string, + suite: string, machine: string, commit: string, metric: string, tests: string[], signal?: AbortSignal, ): Promise { - const key = baselineKey(suite, machine, order, metric); + const key = baselineKey(suite, machine, commit, metric); const cached = this.baselineData.get(key); if (cached) { @@ -192,7 +191,7 @@ export class GraphDataCache { const body: Record = { machine, metric, - order, + commit, test: tests, limit: PAGE_LIMIT, }; @@ -218,8 +217,8 @@ export class GraphDataCache { return entry?.complete ?? false; } - readCachedBaselineData(suite: string, machine: string, order: string, metric: string): QueryDataPoint[] { - const key = baselineKey(suite, machine, order, metric); + readCachedBaselineData(suite: string, machine: string, commit: string, metric: string): QueryDataPoint[] { + const key = baselineKey(suite, machine, commit, metric); const entry = this.baselineData.get(key); return entry ? entry.points : []; } diff --git a/lnt/server/ui/v5/frontend/src/pages/graph.ts b/lnt/server/ui/v5/frontend/src/pages/graph.ts index ddedff2fb..876eb95e5 100644 --- a/lnt/server/ui/v5/frontend/src/pages/graph.ts +++ b/lnt/server/ui/v5/frontend/src/pages/graph.ts @@ -2,8 +2,8 @@ import type { PageModule, RouteParams } from '../router'; import type { AggFn, QueryDataPoint } from '../types'; -import { getFields, getOrders, fetchOneCursorPage, postOneCursorPage, apiUrl } from '../api'; -import { el, debounce, getAggFn, primaryOrderValue, TRACE_SEP, machineColor } from '../utils'; +import { getFields, getCommits, fetchOneCursorPage, postOneCursorPage, apiUrl } from '../api'; +import { el, debounce, getAggFn, TRACE_SEP, machineColor } from '../utils'; import { getTestsuites } from '../router'; import { onCustomEvent, GRAPH_TABLE_HOVER, GRAPH_CHART_HOVER } from '../events'; import { renderMachineCombobox } from '../components/machine-combobox'; @@ -33,17 +33,16 @@ let cache = new GraphDataCache({ apiUrl, fetchOneCursorPage, postOneCursorPage } let fetchAbort: AbortController | null = null; let filterAbort: AbortController | null = null; let selectionAbort: AbortController | null = null; -/** Per-suite order list cache for baseline order picker. */ -let baselineOrderCache = new Map }>(); -/** Machine-order filter set for the baseline order picker (null = loading or no machine). */ -let blMachineOrders: Set | null = null; +/** Per-suite commit list cache for baseline commit picker. */ +let baselineCommitCache = new Map(); +/** Machine-commit filter set for the baseline commit picker (null = loading or no machine). */ +let blMachineCommits: Set | null = null; /** A cross-suite baseline reference line. */ export interface Baseline { suite: string; machine: string; - order: string; - tag: string | null; + commit: string; } // --------------------------------------------------------------------------- @@ -59,7 +58,7 @@ let loadingTests = new Set(); let machineComboCleanup: (() => void) | null = null; let blMachineCleanup: (() => void) | null = null; -let blOrderCleanup: (() => void) | null = null; +let blCommitCleanup: (() => void) | null = null; let chartHandle: ChartHandle | null = null; let tableHandle: TestSelectionTableHandle | null = null; /** Pending requestAnimationFrame ID for deferred chart updates. */ @@ -118,12 +117,12 @@ export const graphPage: PageModule = { ? urlParams.get('run_agg') as AggFn : 'median'; let sampleAgg: AggFn = (['median', 'mean', 'min', 'max'] as AggFn[]).includes(urlParams.get('sample_agg') as AggFn) ? urlParams.get('sample_agg') as AggFn : 'median'; - // Baselines encoded as "suite::machine::order". + // Baselines encoded as "suite::machine::commit". const baselineParams = urlParams.getAll('baseline'); const baselines: Baseline[] = baselineParams.map(v => { const parts = v.split('::'); - return { suite: parts[0] || '', machine: parts[1] || '', order: parts[2] || '', tag: null }; - }).filter(b => b.suite && b.machine && b.order); + return { suite: parts[0] || '', machine: parts[1] || '', commit: parts[2] || '' }; + }).filter(b => b.suite && b.machine && b.commit); // Progress + chart containers const progressContainer = el('div', {}); @@ -263,48 +262,48 @@ export const graphPage: PageModule = { const baselineFormContainer = el('div', { class: 'baseline-form', style: 'display: none' }); const addBaselineBtn = el('button', { class: 'add-baseline-btn' }, '+ Add baseline'); - // Baseline form: Suite, Machine, Order in a horizontal row + // Baseline form: Suite, Machine, Commit in a horizontal row const blSuiteSelect = el('select', { class: 'suite-select baseline-suite' }) as HTMLSelectElement; blSuiteSelect.append(el('option', { value: '' }, '-- Suite --')); for (const name of getTestsuites()) { blSuiteSelect.append(el('option', { value: name }, name)); } const blMachineContainer = el('div', {}); - const blOrderContainer = el('div', {}); + const blCommitContainer = el('div', {}); let blSelectedMachine = ''; function addCurrentBaseline(): void { const suite = blSuiteSelect.value; - if (!suite || !blSelectedMachine || !blSelectedOrder) return; + if (!suite || !blSelectedMachine || !blSelectedCommit) return; // Avoid duplicates - if (baselines.find(b => b.suite === suite && b.machine === blSelectedMachine && b.order === blSelectedOrder)) return; - baselines.push({ suite, machine: blSelectedMachine, order: blSelectedOrder, tag: null }); + if (baselines.find(b => b.suite === suite && b.machine === blSelectedMachine && b.commit === blSelectedCommit)) return; + baselines.push({ suite, machine: blSelectedMachine, commit: blSelectedCommit }); renderBaselineChips(); // Fetch baseline data for SELECTED tests and re-render if (metric && selectedTests.size > 0) { const bl = baselines[baselines.length - 1]; - cache.getBaselineData(bl.suite, bl.machine, bl.order, metric, [...selectedTests], fetchAbort?.signal) + cache.getBaselineData(bl.suite, bl.machine, bl.commit, metric, [...selectedTests], fetchAbort?.signal) .then(() => renderFromSelection()) .catch(() => { /* baseline data is optional */ }); } updateUrlState(); // Reset: keep form open for adding more, but clear selections blSelectedMachine = ''; - blSelectedOrder = ''; + blSelectedCommit = ''; blSuiteSelect.value = ''; blSuiteSelect.dispatchEvent(new Event('change')); } - // Track the selected order — set by onSelect callback from order search - let blSelectedOrder = ''; + // Track the selected commit — set by onSelect callback from commit search + let blSelectedCommit = ''; blSuiteSelect.addEventListener('change', () => { blSelectedMachine = ''; - blSelectedOrder = ''; + blSelectedCommit = ''; if (blMachineCleanup) { blMachineCleanup(); blMachineCleanup = null; } - if (blOrderCleanup) { blOrderCleanup(); blOrderCleanup = null; } + if (blCommitCleanup) { blCommitCleanup(); blCommitCleanup = null; } blMachineContainer.replaceChildren(); - blOrderContainer.replaceChildren(); + blCommitContainer.replaceChildren(); const suite = blSuiteSelect.value; if (!suite) return; @@ -313,61 +312,58 @@ export const graphPage: PageModule = { testsuite: suite, onSelect: async (name) => { blSelectedMachine = name; - blSelectedOrder = ''; - blMachineOrders = null; - if (blOrderCleanup) { blOrderCleanup(); blOrderCleanup = null; } - blOrderContainer.replaceChildren(); - - // Fetch order list and machine orders in parallel - const orderListPromise = (async () => { - if (baselineOrderCache.has(suite)) return; + blSelectedCommit = ''; + blMachineCommits = null; + if (blCommitCleanup) { blCommitCleanup(); blCommitCleanup = null; } + blCommitContainer.replaceChildren(); + + // Fetch commit list and machine commits in parallel + const commitListPromise = (async () => { + if (baselineCommitCache.has(suite)) return; try { - const orders = await getOrders(suite, fetchAbort?.signal); + const commits = await getCommits(suite, fetchAbort?.signal); const values: string[] = []; - const tags = new Map(); - for (const o of orders) { - const v = primaryOrderValue(o.fields); - values.push(v); - tags.set(v, o.tag ?? null); + for (const o of commits) { + values.push(o.commit); } - baselineOrderCache.set(suite, { values, tags }); + baselineCommitCache.set(suite, values); } catch (err: unknown) { if (err instanceof DOMException && err.name === 'AbortError') return; - baselineOrderCache.set(suite, { values: [], tags: new Map() }); + baselineCommitCache.set(suite, []); } })(); const machineOrdersPromise = fetchMachineOrderSet(suite, name) .catch(() => null as Set | null); - await orderListPromise; + await commitListPromise; - // Create order picker with machine-order filtering + // Create order picker with machine-commit filtering const picker = createOrderPicker({ id: 'baseline-order', getOrderData: () => { - const d = baselineOrderCache.get(suite); - return d ?? { values: [], tags: new Map() }; + const values = baselineCommitCache.get(suite); + return { cachedOrderValues: values ?? null, orderTags: new Map() }; }, placeholder: 'Type to search orders...', onSelect: (value) => { - blSelectedOrder = value; + blSelectedCommit = value; addCurrentBaseline(); }, - getMachineOrders: () => blSelectedMachine ? (blMachineOrders ?? 'loading') : null, + getMachineOrders: () => blSelectedMachine ? (blMachineCommits ?? 'loading') : null, }); - blOrderContainer.append(picker.element); - blOrderCleanup = picker.destroy; + blCommitContainer.append(picker.element); + blCommitCleanup = picker.destroy; // Apply machine orders once ready (may already be resolved) const machineOrders = await machineOrdersPromise; - blMachineOrders = machineOrders; + blMachineCommits = machineOrders; }, onClear: () => { blSelectedMachine = ''; - blSelectedOrder = ''; - blMachineOrders = null; - if (blOrderCleanup) { blOrderCleanup(); blOrderCleanup = null; } - blOrderContainer.replaceChildren(); + blSelectedCommit = ''; + blMachineCommits = null; + if (blCommitCleanup) { blCommitCleanup(); blCommitCleanup = null; } + blCommitContainer.replaceChildren(); }, }); blMachineCleanup = handle.destroy; @@ -378,9 +374,9 @@ export const graphPage: PageModule = { addBaselineBtn.style.display = 'none'; }); - // Horizontal row for Suite → Machine → Order + // Horizontal row for Suite → Machine → Commit const formRow = el('div', { class: 'baseline-form-row' }); - formRow.append(blSuiteSelect, blMachineContainer, blOrderContainer); + formRow.append(blSuiteSelect, blMachineContainer, blCommitContainer); baselineFormContainer.append(formRow); baselineGroup.append(addBaselineBtn, baselineFormContainer, baselineChips); firstRow.append(baselineGroup); @@ -390,7 +386,7 @@ export const graphPage: PageModule = { function renderBaselineChips(): void { baselineChips.replaceChildren(); for (const bl of baselines) { - const label = bl.tag ? `${bl.suite}/${bl.machine}/${bl.order} (${bl.tag})` : `${bl.suite}/${bl.machine}/${bl.order}`; + const label = `${bl.suite}/${bl.machine}/${bl.commit}`; const chip = el('span', { class: 'chip' }, label); const removeBtn = el('button', { class: 'chip-remove' }, '\u00d7'); removeBtn.addEventListener('click', () => { @@ -510,7 +506,7 @@ export const graphPage: PageModule = { // Fetch baseline data for selected tests if (baselines.length > 0) { await Promise.all(baselines.map(bl => - cache.getBaselineData(bl.suite, bl.machine, bl.order, metric, + cache.getBaselineData(bl.suite, bl.machine, bl.commit, metric, [...selectedTests], sig), )); } @@ -585,10 +581,10 @@ export const graphPage: PageModule = { (s, m, o, met) => cache.readCachedBaselineData(s, m, o, met), metric, getAggFn(runAgg)); const scaffold = cache.scaffoldUnion(currentSuite, machines); - const rawValuesCallback = (testName: string, machineName: string, orderValue: string): number[] => { + const rawValuesCallback = (testName: string, machineName: string, commitValue: string): number[] => { const values: number[] = []; for (const pt of allPoints) { - if (pt.test === testName && pt.machine === machineName && primaryOrderValue(pt.order) === orderValue) { + if (pt.test === testName && pt.machine === machineName && pt.commit === commitValue) { values.push(pt.value); } } @@ -760,7 +756,7 @@ export const graphPage: PageModule = { if (testFilter) qs.set('test_filter', testFilter); if (runAgg !== 'median') qs.set('run_agg', runAgg); if (sampleAgg !== 'median') qs.set('sample_agg', sampleAgg); - for (const bl of baselines) qs.append('baseline', `${bl.suite}::${bl.machine}::${bl.order}`); + for (const bl of baselines) qs.append('baseline', `${bl.suite}::${bl.machine}::${bl.commit}`); window.history.replaceState(null, '', window.location.pathname + '?' + qs.toString()); } @@ -782,8 +778,8 @@ export const graphPage: PageModule = { allMatchingTests = []; selectedTests = new Set(); loadingTests = new Set(); - baselineOrderCache.clear(); - blMachineOrders = null; + baselineCommitCache.clear(); + blMachineCommits = null; baselines.length = 0; if (pendingChartRAF !== null) { cancelAnimationFrame(pendingChartRAF); pendingChartRAF = null; } chartRenderGen = 0; @@ -793,7 +789,7 @@ export const graphPage: PageModule = { if (tableHandle) { tableHandle.destroy(); tableHandle = null; } if (machineComboCleanup) { machineComboCleanup(); machineComboCleanup = null; } if (blMachineCleanup) { blMachineCleanup(); blMachineCleanup = null; } - if (blOrderCleanup) { blOrderCleanup(); blOrderCleanup = null; } + if (blCommitCleanup) { blCommitCleanup(); blCommitCleanup = null; } // Clear controls containers machineChipsEl.replaceChildren(); @@ -803,9 +799,9 @@ export const graphPage: PageModule = { addBaselineBtn.style.display = ''; blSuiteSelect.value = ''; blMachineContainer.replaceChildren(); - blOrderContainer.replaceChildren(); + blCommitContainer.replaceChildren(); blSelectedMachine = ''; - blSelectedOrder = ''; + blSelectedCommit = ''; chartContainer.replaceChildren(el('p', { class: 'no-chart-data' }, 'No data to plot.')); tableContainer.replaceChildren(); progressContainer.replaceChildren(); @@ -872,7 +868,7 @@ export const graphPage: PageModule = { unmount(): void { if (machineComboCleanup) { machineComboCleanup(); machineComboCleanup = null; } if (blMachineCleanup) { blMachineCleanup(); blMachineCleanup = null; } - if (blOrderCleanup) { blOrderCleanup(); blOrderCleanup = null; } + if (blCommitCleanup) { blCommitCleanup(); blCommitCleanup = null; } abortFetches(); if (filterAbort) { filterAbort.abort(); filterAbort = null; } if (selectionAbort) { selectionAbort.abort(); selectionAbort = null; } @@ -886,8 +882,8 @@ export const graphPage: PageModule = { chartRenderGen = 0; currentSuite = ''; suiteGeneration = 0; - baselineOrderCache.clear(); - blMachineOrders = null; + baselineCommitCache.clear(); + blMachineCommits = null; // Intentionally preserve selectedTests, allMatchingTests, and cache across // unmount/remount so that navigating back renders instantly from cache. // machines is restored from URL on mount. @@ -916,20 +912,20 @@ export function buildTraces( const traces: TimeSeriesTrace[] = []; for (const [testName, testPoints] of testMap) { - // Group by order value - const orderMap = new Map(); + // Group by commit value + const commitMap = new Map(); for (const pt of testPoints) { - const ov = primaryOrderValue(pt.order); - let arr = orderMap.get(ov); - if (!arr) { arr = []; orderMap.set(ov, arr); } + const ov = pt.commit; + let arr = commitMap.get(ov); + if (!arr) { arr = []; commitMap.set(ov, arr); } arr.push(pt); } const tracePoints: TimeSeriesTrace['points'] = []; - for (const [orderValue, orderPoints] of orderMap) { + for (const [commitValue, commitPoints] of commitMap) { // Step 1: group by run_uuid const byRun = new Map(); - for (const pt of orderPoints) { + for (const pt of commitPoints) { let arr = byRun.get(pt.run_uuid); if (!arr) { arr = []; byRun.set(pt.run_uuid, arr); } arr.push(pt.value); @@ -938,10 +934,10 @@ export function buildTraces( const perRunValues = [...byRun.values()].map(v => sampleAggFn(v)); // Step 3: aggregate across runs tracePoints.push({ - orderValue, + commit: commitValue, value: runAggFn(perRunValues), runCount: byRun.size, - timestamp: orderPoints[0].timestamp, + submitted_at: commitPoints[0].submitted_at, }); } @@ -958,13 +954,13 @@ export function buildTraces( * Exported for testing. */ export function buildBaselinesFromData( - baselines: Array<{ suite: string; machine: string; order: string; tag: string | null }>, + baselines: Array<{ suite: string; machine: string; commit: string }>, getPoints: (suite: string, machine: string, order: string, metric: string) => QueryDataPoint[], metric: string, aggFn: (values: number[]) => number, ): PinnedBaseline[] { return baselines.map((bl) => { - const points = getPoints(bl.suite, bl.machine, bl.order, metric); + const points = getPoints(bl.suite, bl.machine, bl.commit, metric); const rawPerTest = new Map(); for (const pt of points) { @@ -978,13 +974,10 @@ export function buildBaselinesFromData( values.set(test, aggFn(raw)); } - const label = bl.tag - ? `${bl.suite}/${bl.machine}/${bl.order} (${bl.tag})` - : `${bl.suite}/${bl.machine}/${bl.order}`; + const label = `${bl.suite}/${bl.machine}/${bl.commit}`; return { label, - tag: bl.tag, values, }; }); From 5571031eec193baa8d15190f925f303c7c82d155 Mon Sep 17 00:00:00 2001 From: Louis Dionne Date: Tue, 14 Apr 2026 17:39:00 -0400 Subject: [PATCH 058/143] [UI] Rebase combobox, selection and compare from Order to Commit Rename order picker to commit picker, remove tag display logic throughout, update selection module to use CommitSummary and getCommits, fix graph.ts combobox imports. All 658 tests pass and Vite build succeeds. Co-Authored-By: Claude Opus 4.6 (1M context) --- .../frontend/src/__tests__/combobox.test.ts | 359 +++++++++--------- .../src/__tests__/pages/compare.test.ts | 20 +- .../src/__tests__/pages/graph.test.ts | 10 +- .../frontend/src/__tests__/selection.test.ts | 6 +- lnt/server/ui/v5/frontend/src/combobox.ts | 226 ++++++----- .../ui/v5/frontend/src/pages/compare.ts | 2 +- lnt/server/ui/v5/frontend/src/pages/graph.ts | 14 +- lnt/server/ui/v5/frontend/src/selection.ts | 63 ++- 8 files changed, 333 insertions(+), 367 deletions(-) diff --git a/lnt/server/ui/v5/frontend/src/__tests__/combobox.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/combobox.test.ts index b53d799cf..dad26e200 100644 --- a/lnt/server/ui/v5/frontend/src/__tests__/combobox.test.ts +++ b/lnt/server/ui/v5/frontend/src/__tests__/combobox.test.ts @@ -11,16 +11,15 @@ vi.mock('../api', () => ({ import { getMachines, getMachineRuns } from '../api'; import { - createMachineCombobox, createOrderCombobox, createOrderPicker, - fetchMachineOrderSet, resetComboboxState, type ComboboxContext, + createMachineCombobox, createCommitCombobox, createCommitPicker, + fetchMachineCommitSet, resetComboboxState, type ComboboxContext, } from '../combobox'; function makeContext(overrides?: Partial): ComboboxContext { - const sideA: SideSelection = { suite: '', order: '', machine: '', runs: [], runAgg: 'median' }; + const sideA: SideSelection = { suite: '', commit: '', machine: '', runs: [], runAgg: 'median' }; return { - getOrderData: () => ({ - cachedOrderValues: ['100', '101', '102'], - orderTags: new Map([['100', 'release-1'], ['101', null], ['102', 'release-2']]), + getCommitData: () => ({ + cachedCommitValues: ['100', '101', '102'], }), getSuiteName: () => 'nts', getSideState: () => ({ @@ -32,15 +31,15 @@ function makeContext(overrides?: Partial): ComboboxContext { }; } -describe('createOrderCombobox', () => { +describe('createCommitCombobox', () => { beforeEach(() => { vi.clearAllMocks(); resetComboboxState(); }); - it('shows tags in dropdown items', () => { + it('shows values in dropdown items', () => { const ctx = makeContext(); - const wrapper = createOrderCombobox('a', () => {}, () => {}, ctx); + const wrapper = createCommitCombobox('a', () => {}, () => {}, ctx); document.body.append(wrapper); const input = wrapper.querySelector('input')!; @@ -48,32 +47,32 @@ describe('createOrderCombobox', () => { const items = wrapper.querySelectorAll('.combobox-item'); const texts = Array.from(items).map(li => li.textContent); - expect(texts).toContain('100 (release-1)'); + expect(texts).toContain('100'); expect(texts).toContain('101'); - expect(texts).toContain('102 (release-2)'); + expect(texts).toContain('102'); wrapper.remove(); }); - it('filters by tag text', () => { + it('filters by commit value substring', () => { const ctx = makeContext(); - const wrapper = createOrderCombobox('a', () => {}, () => {}, ctx); + const wrapper = createCommitCombobox('a', () => {}, () => {}, ctx); document.body.append(wrapper); const input = wrapper.querySelector('input')! as HTMLInputElement; - input.value = 'release-2'; + input.value = '102'; input.dispatchEvent(new Event('input')); const items = wrapper.querySelectorAll('.combobox-item'); expect(items).toHaveLength(1); - expect(items[0].textContent).toBe('102 (release-2)'); + expect(items[0].textContent).toBe('102'); wrapper.remove(); }); - it('filters by order value', () => { + it('filters by commit value', () => { const ctx = makeContext(); - const wrapper = createOrderCombobox('a', () => {}, () => {}, ctx); + const wrapper = createCommitCombobox('a', () => {}, () => {}, ctx); document.body.append(wrapper); const input = wrapper.querySelector('input')! as HTMLInputElement; @@ -87,8 +86,8 @@ describe('createOrderCombobox', () => { wrapper.remove(); }); - it('shows loading hint when machine is set but orders not loaded', () => { - const sideA: SideSelection = { suite: '', order: '', machine: 'clang-x86', runs: [], runAgg: 'median' }; + it('shows loading hint when machine is set but commits not loaded', () => { + const sideA: SideSelection = { suite: '', commit: '', machine: 'clang-x86', runs: [], runAgg: 'median' }; const ctx = makeContext({ getSideState: () => ({ selection: sideA, @@ -96,8 +95,8 @@ describe('createOrderCombobox', () => { label: 'Side A', }), }); - // machineOrdersA is null (not loaded) — resetComboboxState ensures this - const wrapper = createOrderCombobox('a', () => {}, () => {}, ctx); + // machineCommitsA is null (not loaded) — resetComboboxState ensures this + const wrapper = createCommitCombobox('a', () => {}, () => {}, ctx); document.body.append(wrapper); const input = wrapper.querySelector('input')!; @@ -105,13 +104,13 @@ describe('createOrderCombobox', () => { const items = wrapper.querySelectorAll('.combobox-item'); expect(items).toHaveLength(1); - expect(items[0].textContent).toBe('Loading orders...'); + expect(items[0].textContent).toBe('Loading commits...'); wrapper.remove(); }); - it('calls setSide with order value (not tag) on selection', () => { - const sideA: SideSelection = { suite: '', order: '', machine: '', runs: [], runAgg: 'median' }; + it('calls setSide with commit value on selection', () => { + const sideA: SideSelection = { suite: '', commit: '', machine: '', runs: [], runAgg: 'median' }; const setSide = vi.fn(); const ctx = makeContext({ getSideState: () => ({ @@ -120,24 +119,24 @@ describe('createOrderCombobox', () => { label: 'Side A', }), }); - const wrapper = createOrderCombobox('a', setSide, () => {}, ctx); + const wrapper = createCommitCombobox('a', setSide, () => {}, ctx); document.body.append(wrapper); const input = wrapper.querySelector('input')!; input.dispatchEvent(new Event('focus')); const items = wrapper.querySelectorAll('.combobox-item'); - // Click the tagged item "100 (release-1)" + // Click the first item "100" (items[0] as HTMLElement).click(); - expect(setSide).toHaveBeenCalledWith({ order: '100' }); + expect(setSide).toHaveBeenCalledWith({ commit: '100' }); wrapper.remove(); }); - it('shows tag in input after selection', () => { + it('shows value in input after selection', () => { const ctx = makeContext(); - const wrapper = createOrderCombobox('a', () => {}, () => {}, ctx); + const wrapper = createCommitCombobox('a', () => {}, () => {}, ctx); document.body.append(wrapper); const input = wrapper.querySelector('input')! as HTMLInputElement; @@ -146,13 +145,13 @@ describe('createOrderCombobox', () => { const items = wrapper.querySelectorAll('.combobox-item'); (items[0] as HTMLElement).click(); - expect(input.value).toBe('100 (release-1)'); + expect(input.value).toBe('100'); wrapper.remove(); }); - it('shows tag in input on URL restore', () => { - const sideA: SideSelection = { suite: '', order: '102', machine: '', runs: [], runAgg: 'median' }; + it('shows value in input on URL restore', () => { + const sideA: SideSelection = { suite: '', commit: '102', machine: '', runs: [], runAgg: 'median' }; const ctx = makeContext({ getSideState: () => ({ selection: sideA, @@ -160,17 +159,17 @@ describe('createOrderCombobox', () => { label: 'Side A', }), }); - const wrapper = createOrderCombobox('a', () => {}, () => {}, ctx); + const wrapper = createCommitCombobox('a', () => {}, () => {}, ctx); document.body.append(wrapper); const input = wrapper.querySelector('input')! as HTMLInputElement; - expect(input.value).toBe('102 (release-2)'); + expect(input.value).toBe('102'); wrapper.remove(); }); - it('shows plain value when order has no tag', () => { - const sideA: SideSelection = { suite: '', order: '101', machine: '', runs: [], runAgg: 'median' }; + it('shows value in input for existing commit', () => { + const sideA: SideSelection = { suite: '', commit: '101', machine: '', runs: [], runAgg: 'median' }; const ctx = makeContext({ getSideState: () => ({ selection: sideA, @@ -178,7 +177,7 @@ describe('createOrderCombobox', () => { label: 'Side A', }), }); - const wrapper = createOrderCombobox('a', () => {}, () => {}, ctx); + const wrapper = createCommitCombobox('a', () => {}, () => {}, ctx); document.body.append(wrapper); const input = wrapper.querySelector('input')! as HTMLInputElement; @@ -187,8 +186,8 @@ describe('createOrderCombobox', () => { wrapper.remove(); }); - it('disables order input when no machine is selected', () => { - const sideA: SideSelection = { suite: 'nts', order: '', machine: '', runs: [], runAgg: 'median' }; + it('disables commit input when no machine is selected', () => { + const sideA: SideSelection = { suite: 'nts', commit: '', machine: '', runs: [], runAgg: 'median' }; const ctx = makeContext({ getSideState: () => ({ selection: sideA, @@ -196,7 +195,7 @@ describe('createOrderCombobox', () => { label: 'Side A', }), }); - const wrapper = createOrderCombobox('a', () => {}, () => {}, ctx); + const wrapper = createCommitCombobox('a', () => {}, () => {}, ctx); document.body.append(wrapper); const input = wrapper.querySelector('input')! as HTMLInputElement; @@ -206,8 +205,8 @@ describe('createOrderCombobox', () => { wrapper.remove(); }); - it('does not disable order input when machine is selected', () => { - const sideA: SideSelection = { suite: 'nts', order: '', machine: 'clang-x86', runs: [], runAgg: 'median' }; + it('does not disable commit input when machine is selected', () => { + const sideA: SideSelection = { suite: 'nts', commit: '', machine: 'clang-x86', runs: [], runAgg: 'median' }; const ctx = makeContext({ getSideState: () => ({ selection: sideA, @@ -215,7 +214,7 @@ describe('createOrderCombobox', () => { label: 'Side A', }), }); - const wrapper = createOrderCombobox('a', () => {}, () => {}, ctx); + const wrapper = createCommitCombobox('a', () => {}, () => {}, ctx); document.body.append(wrapper); const input = wrapper.querySelector('input')! as HTMLInputElement; @@ -226,23 +225,17 @@ describe('createOrderCombobox', () => { }); // --------------------------------------------------------------------------- -const ORDER_VALUES = ['100', '101', '102', '200']; -const ORDER_TAGS = new Map([ - ['100', 'release-1'], - ['101', null], - ['102', 'release-2'], - ['200', 'beta-1'], -]); +const COMMIT_VALUES = ['100', '101', '102', '200']; -describe('createOrderPicker', () => { +describe('createCommitPicker', () => { beforeEach(() => { vi.clearAllMocks(); }); it('renders a combobox wrapper with input and dropdown', () => { - const picker = createOrderPicker({ + const picker = createCommitPicker({ id: 'test', - getOrderData: () => ({ values: ORDER_VALUES, tags: ORDER_TAGS }), + getCommitData: () => ({ values: COMMIT_VALUES }), onSelect: () => {}, }); document.body.append(picker.element); @@ -254,10 +247,10 @@ describe('createOrderPicker', () => { picker.element.remove(); }); - it('shows all orders on focus', () => { - const picker = createOrderPicker({ + it('shows all commits on focus', () => { + const picker = createCommitPicker({ id: 'test', - getOrderData: () => ({ values: ORDER_VALUES, tags: ORDER_TAGS }), + getCommitData: () => ({ values: COMMIT_VALUES }), onSelect: () => {}, }); document.body.append(picker.element); @@ -270,10 +263,10 @@ describe('createOrderPicker', () => { picker.element.remove(); }); - it('displays tags in dropdown items', () => { - const picker = createOrderPicker({ + it('displays values in dropdown items', () => { + const picker = createCommitPicker({ id: 'test', - getOrderData: () => ({ values: ORDER_VALUES, tags: ORDER_TAGS }), + getCommitData: () => ({ values: COMMIT_VALUES }), onSelect: () => {}, }); document.body.append(picker.element); @@ -282,18 +275,18 @@ describe('createOrderPicker', () => { const items = picker.element.querySelectorAll('.combobox-item'); const texts = Array.from(items).map(li => li.textContent); - expect(texts).toContain('100 (release-1)'); + expect(texts).toContain('100'); expect(texts).toContain('101'); - expect(texts).toContain('102 (release-2)'); - expect(texts).toContain('200 (beta-1)'); + expect(texts).toContain('102'); + expect(texts).toContain('200'); picker.element.remove(); }); - it('filters by order value', () => { - const picker = createOrderPicker({ + it('filters by commit value', () => { + const picker = createCommitPicker({ id: 'test', - getOrderData: () => ({ values: ORDER_VALUES, tags: ORDER_TAGS }), + getCommitData: () => ({ values: COMMIT_VALUES }), onSelect: () => {}, }); document.body.append(picker.element); @@ -303,34 +296,34 @@ describe('createOrderPicker', () => { const items = picker.element.querySelectorAll('.combobox-item'); expect(items).toHaveLength(3); // 100, 101, 102 - expect(Array.from(items).map(li => li.textContent)).not.toContain('200 (beta-1)'); + expect(Array.from(items).map(li => li.textContent)).not.toContain('200'); picker.element.remove(); }); - it('filters by tag text', () => { - const picker = createOrderPicker({ + it('filters by commit value prefix', () => { + const picker = createCommitPicker({ id: 'test', - getOrderData: () => ({ values: ORDER_VALUES, tags: ORDER_TAGS }), + getCommitData: () => ({ values: COMMIT_VALUES }), onSelect: () => {}, }); document.body.append(picker.element); - picker.input.value = 'beta'; + picker.input.value = '200'; picker.input.dispatchEvent(new Event('input')); const items = picker.element.querySelectorAll('.combobox-item'); expect(items).toHaveLength(1); - expect(items[0].textContent).toBe('200 (beta-1)'); + expect(items[0].textContent).toBe('200'); picker.element.remove(); }); - it('calls onSelect with order value (not tag) on click', () => { + it('calls onSelect with commit value on click', () => { const onSelect = vi.fn(); - const picker = createOrderPicker({ + const picker = createCommitPicker({ id: 'test', - getOrderData: () => ({ values: ORDER_VALUES, tags: ORDER_TAGS }), + getCommitData: () => ({ values: COMMIT_VALUES }), onSelect, }); document.body.append(picker.element); @@ -338,17 +331,17 @@ describe('createOrderPicker', () => { picker.input.dispatchEvent(new Event('focus')); const items = picker.element.querySelectorAll('.combobox-item'); - (items[0] as HTMLElement).click(); // "100 (release-1)" + (items[0] as HTMLElement).click(); // "100" expect(onSelect).toHaveBeenCalledWith('100'); picker.element.remove(); }); - it('sets input value with tag on selection', () => { - const picker = createOrderPicker({ + it('sets input value on selection', () => { + const picker = createCommitPicker({ id: 'test', - getOrderData: () => ({ values: ORDER_VALUES, tags: ORDER_TAGS }), + getCommitData: () => ({ values: COMMIT_VALUES }), onSelect: () => {}, }); document.body.append(picker.element); @@ -357,15 +350,15 @@ describe('createOrderPicker', () => { const items = picker.element.querySelectorAll('.combobox-item'); (items[0] as HTMLElement).click(); - expect(picker.input.value).toBe('100 (release-1)'); + expect(picker.input.value).toBe('100'); picker.element.remove(); }); it('keeps dropdown open when ArrowDown moves focus to an item', () => { - const picker = createOrderPicker({ + const picker = createCommitPicker({ id: 'test', - getOrderData: () => ({ values: ORDER_VALUES, tags: ORDER_TAGS }), + getCommitData: () => ({ values: COMMIT_VALUES }), onSelect: () => {}, }); document.body.append(picker.element); @@ -385,9 +378,9 @@ describe('createOrderPicker', () => { it('selects item via ArrowDown then Enter', () => { const onSelect = vi.fn(); - const picker = createOrderPicker({ + const picker = createCommitPicker({ id: 'test', - getOrderData: () => ({ values: ORDER_VALUES, tags: ORDER_TAGS }), + getCommitData: () => ({ values: COMMIT_VALUES }), onSelect, }); document.body.append(picker.element); @@ -405,19 +398,16 @@ describe('createOrderPicker', () => { picker.element.remove(); }); - it('strips tag suffix on change event', () => { + it('accepts value on change event', () => { const onSelect = vi.fn(); - const picker = createOrderPicker({ + const picker = createCommitPicker({ id: 'test', - getOrderData: () => ({ values: ORDER_VALUES, tags: ORDER_TAGS }), + getCommitData: () => ({ values: COMMIT_VALUES }), onSelect, }); document.body.append(picker.element); - // Simulate: user clicked "100 (release-1)" from dropdown (which set the - // input value), then blurred — change event fires with the tagged display - // value. The handler strips the tag suffix before calling onSelect. - picker.input.value = '100 (release-1)'; + picker.input.value = '100'; picker.input.dispatchEvent(new Event('change')); expect(onSelect).toHaveBeenCalledWith('100'); @@ -425,24 +415,24 @@ describe('createOrderPicker', () => { picker.element.remove(); }); - it('sets initial value with tag', () => { - const picker = createOrderPicker({ + it('sets initial value', () => { + const picker = createCommitPicker({ id: 'test', - getOrderData: () => ({ values: ORDER_VALUES, tags: ORDER_TAGS }), + getCommitData: () => ({ values: COMMIT_VALUES }), initialValue: '100', onSelect: () => {}, }); document.body.append(picker.element); - expect(picker.input.value).toBe('100 (release-1)'); + expect(picker.input.value).toBe('100'); picker.element.remove(); }); - it('sets initial value without tag when tag is null', () => { - const picker = createOrderPicker({ + it('sets initial value for any commit', () => { + const picker = createCommitPicker({ id: 'test', - getOrderData: () => ({ values: ORDER_VALUES, tags: ORDER_TAGS }), + getCommitData: () => ({ values: COMMIT_VALUES }), initialValue: '101', onSelect: () => {}, }); @@ -450,13 +440,13 @@ describe('createOrderPicker', () => { expect(picker.input.value).toBe('101'); }); - it('respects getMachineOrders filter', () => { - const machineOrders = new Set(['100', '200']); - const picker = createOrderPicker({ + it('respects getMachineCommits filter', () => { + const machineCommits = new Set(['100', '200']); + const picker = createCommitPicker({ id: 'test', - getOrderData: () => ({ values: ORDER_VALUES, tags: ORDER_TAGS }), + getCommitData: () => ({ values: COMMIT_VALUES }), onSelect: () => {}, - getMachineOrders: () => machineOrders, + getMachineCommits: () => machineCommits, }); document.body.append(picker.element); @@ -465,18 +455,18 @@ describe('createOrderPicker', () => { const items = picker.element.querySelectorAll('.combobox-item'); expect(items).toHaveLength(2); const texts = Array.from(items).map(li => li.textContent); - expect(texts).toContain('100 (release-1)'); - expect(texts).toContain('200 (beta-1)'); + expect(texts).toContain('100'); + expect(texts).toContain('200'); picker.element.remove(); }); - it('shows loading hint when getMachineOrders returns loading', () => { - const picker = createOrderPicker({ + it('shows loading hint when getMachineCommits returns loading', () => { + const picker = createCommitPicker({ id: 'test', - getOrderData: () => ({ values: ORDER_VALUES, tags: ORDER_TAGS }), + getCommitData: () => ({ values: COMMIT_VALUES }), onSelect: () => {}, - getMachineOrders: () => 'loading', + getMachineCommits: () => 'loading', }); document.body.append(picker.element); @@ -484,17 +474,17 @@ describe('createOrderPicker', () => { const items = picker.element.querySelectorAll('.combobox-item'); expect(items).toHaveLength(1); - expect(items[0].textContent).toBe('Loading orders...'); + expect(items[0].textContent).toBe('Loading commits...'); picker.element.remove(); }); - it('shows all orders when getMachineOrders returns null', () => { - const picker = createOrderPicker({ + it('shows all commits when getMachineCommits returns null', () => { + const picker = createCommitPicker({ id: 'test', - getOrderData: () => ({ values: ORDER_VALUES, tags: ORDER_TAGS }), + getCommitData: () => ({ values: COMMIT_VALUES }), onSelect: () => {}, - getMachineOrders: () => null, + getMachineCommits: () => null, }); document.body.append(picker.element); @@ -508,10 +498,9 @@ describe('createOrderPicker', () => { it('limits dropdown to 100 items', () => { const values = Array.from({ length: 150 }, (_, i) => String(i)); - const tags = new Map(values.map(v => [v, null])); - const picker = createOrderPicker({ + const picker = createCommitPicker({ id: 'test', - getOrderData: () => ({ values, tags }), + getCommitData: () => ({ values }), onSelect: () => {}, }); document.body.append(picker.element); @@ -525,9 +514,9 @@ describe('createOrderPicker', () => { }); it('closes dropdown on blur', () => { - const picker = createOrderPicker({ + const picker = createCommitPicker({ id: 'test', - getOrderData: () => ({ values: ORDER_VALUES, tags: ORDER_TAGS }), + getCommitData: () => ({ values: COMMIT_VALUES }), onSelect: () => {}, }); document.body.append(picker.element); @@ -542,9 +531,9 @@ describe('createOrderPicker', () => { }); it('uses custom placeholder', () => { - const picker = createOrderPicker({ + const picker = createCommitPicker({ id: 'test', - getOrderData: () => ({ values: ORDER_VALUES, tags: ORDER_TAGS }), + getCommitData: () => ({ values: COMMIT_VALUES }), placeholder: 'Custom placeholder', onSelect: () => {}, }); @@ -554,10 +543,10 @@ describe('createOrderPicker', () => { // --- Validation tests --- - it('shows combobox-invalid on input when no orders match', () => { - const picker = createOrderPicker({ + it('shows combobox-invalid on input when no commits match', () => { + const picker = createCommitPicker({ id: 'test', - getOrderData: () => ({ values: ORDER_VALUES, tags: ORDER_TAGS }), + getCommitData: () => ({ values: COMMIT_VALUES }), onSelect: () => {}, }); document.body.append(picker.element); @@ -570,10 +559,10 @@ describe('createOrderPicker', () => { picker.element.remove(); }); - it('removes combobox-invalid on input when orders match', () => { - const picker = createOrderPicker({ + it('removes combobox-invalid on input when commits match', () => { + const picker = createCommitPicker({ id: 'test', - getOrderData: () => ({ values: ORDER_VALUES, tags: ORDER_TAGS }), + getCommitData: () => ({ values: COMMIT_VALUES }), onSelect: () => {}, }); document.body.append(picker.element); @@ -592,9 +581,9 @@ describe('createOrderPicker', () => { }); it('no combobox-invalid when input is empty', () => { - const picker = createOrderPicker({ + const picker = createCommitPicker({ id: 'test', - getOrderData: () => ({ values: ORDER_VALUES, tags: ORDER_TAGS }), + getCommitData: () => ({ values: COMMIT_VALUES }), onSelect: () => {}, }); document.body.append(picker.element); @@ -609,9 +598,9 @@ describe('createOrderPicker', () => { it('does not call onSelect on change when combobox-invalid', () => { const onSelect = vi.fn(); - const picker = createOrderPicker({ + const picker = createCommitPicker({ id: 'test', - getOrderData: () => ({ values: ORDER_VALUES, tags: ORDER_TAGS }), + getCommitData: () => ({ values: COMMIT_VALUES }), onSelect, }); document.body.append(picker.element); @@ -627,9 +616,9 @@ describe('createOrderPicker', () => { it('calls onSelect on Enter when input is valid', () => { const onSelect = vi.fn(); - const picker = createOrderPicker({ + const picker = createCommitPicker({ id: 'test', - getOrderData: () => ({ values: ORDER_VALUES, tags: ORDER_TAGS }), + getCommitData: () => ({ values: COMMIT_VALUES }), onSelect, }); document.body.append(picker.element); @@ -645,9 +634,9 @@ describe('createOrderPicker', () => { it('does not call onSelect on Enter when input is invalid', () => { const onSelect = vi.fn(); - const picker = createOrderPicker({ + const picker = createCommitPicker({ id: 'test', - getOrderData: () => ({ values: ORDER_VALUES, tags: ORDER_TAGS }), + getCommitData: () => ({ values: COMMIT_VALUES }), onSelect, }); document.body.append(picker.element); @@ -661,12 +650,12 @@ describe('createOrderPicker', () => { picker.element.remove(); }); - it('no combobox-invalid when getMachineOrders returns loading', () => { - const picker = createOrderPicker({ + it('no combobox-invalid when getMachineCommits returns loading', () => { + const picker = createCommitPicker({ id: 'test', - getOrderData: () => ({ values: ORDER_VALUES, tags: ORDER_TAGS }), + getCommitData: () => ({ values: COMMIT_VALUES }), onSelect: () => {}, - getMachineOrders: () => 'loading', + getMachineCommits: () => 'loading', }); document.body.append(picker.element); @@ -678,22 +667,22 @@ describe('createOrderPicker', () => { picker.element.remove(); }); - it('validates against machine-filtered orders', () => { - const machineOrders = new Set(['100', '200']); - const picker = createOrderPicker({ + it('validates against machine-filtered commits', () => { + const machineCommits = new Set(['100', '200']); + const picker = createCommitPicker({ id: 'test', - getOrderData: () => ({ values: ORDER_VALUES, tags: ORDER_TAGS }), + getCommitData: () => ({ values: COMMIT_VALUES }), onSelect: () => {}, - getMachineOrders: () => machineOrders, + getMachineCommits: () => machineCommits, }); document.body.append(picker.element); - // '101' is in ORDER_VALUES but not in machineOrders + // '101' is in COMMIT_VALUES but not in machineCommits picker.input.value = '101'; picker.input.dispatchEvent(new Event('input')); expect(picker.input.classList.contains('combobox-invalid')).toBe(true); - // '100' is in machineOrders + // '100' is in machineCommits picker.input.value = '100'; picker.input.dispatchEvent(new Event('input')); expect(picker.input.classList.contains('combobox-invalid')).toBe(false); @@ -703,9 +692,9 @@ describe('createOrderPicker', () => { it('rejects partial match on Enter (exact-match required)', () => { const onSelect = vi.fn(); - const picker = createOrderPicker({ + const picker = createCommitPicker({ id: 'test', - getOrderData: () => ({ values: ORDER_VALUES, tags: ORDER_TAGS }), + getCommitData: () => ({ values: COMMIT_VALUES }), onSelect, }); document.body.append(picker.element); @@ -724,9 +713,9 @@ describe('createOrderPicker', () => { it('rejects partial match on change (exact-match required)', () => { const onSelect = vi.fn(); - const picker = createOrderPicker({ + const picker = createCommitPicker({ id: 'test', - getOrderData: () => ({ values: ORDER_VALUES, tags: ORDER_TAGS }), + getCommitData: () => ({ values: COMMIT_VALUES }), onSelect, }); document.body.append(picker.element); @@ -742,9 +731,9 @@ describe('createOrderPicker', () => { it('accepts exact match on Enter', () => { const onSelect = vi.fn(); - const picker = createOrderPicker({ + const picker = createCommitPicker({ id: 'test', - getOrderData: () => ({ values: ORDER_VALUES, tags: ORDER_TAGS }), + getCommitData: () => ({ values: COMMIT_VALUES }), onSelect, }); document.body.append(picker.element); @@ -759,9 +748,9 @@ describe('createOrderPicker', () => { it('accepts exact match on change', () => { const onSelect = vi.fn(); - const picker = createOrderPicker({ + const picker = createCommitPicker({ id: 'test', - getOrderData: () => ({ values: ORDER_VALUES, tags: ORDER_TAGS }), + getCommitData: () => ({ values: COMMIT_VALUES }), onSelect, }); document.body.append(picker.element); @@ -774,17 +763,16 @@ describe('createOrderPicker', () => { picker.element.remove(); }); - it('accepts exact match with tag suffix on Enter', () => { + it('accepts exact match on Enter via display value', () => { const onSelect = vi.fn(); - const picker = createOrderPicker({ + const picker = createCommitPicker({ id: 'test', - getOrderData: () => ({ values: ORDER_VALUES, tags: ORDER_TAGS }), + getCommitData: () => ({ values: COMMIT_VALUES }), onSelect, }); document.body.append(picker.element); - // Typing the display label "100 (release-1)" should strip to "100" and accept - picker.input.value = '100 (release-1)'; + picker.input.value = '100'; picker.input.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter' })); expect(onSelect).toHaveBeenCalledWith('100'); @@ -817,11 +805,10 @@ describe('createMachineCombobox', () => { }); function makeMachineCtx(overrides?: Partial): ComboboxContext { - const sideA: SideSelection = { suite: 'nts', order: '', machine: '', runs: [], runAgg: 'median' }; + const sideA: SideSelection = { suite: 'nts', commit: '', machine: '', runs: [], runAgg: 'median' }; return { - getOrderData: () => ({ - cachedOrderValues: [], - orderTags: new Map(), + getCommitData: () => ({ + cachedCommitValues: [], }), getSuiteName: () => 'nts', getSideState: () => ({ @@ -864,7 +851,7 @@ describe('createMachineCombobox', () => { const ctx = makeMachineCtx({ getSuiteName: () => '', getSideState: () => ({ - selection: { suite: '', order: '', machine: '', runs: [], runAgg: 'median' as const }, + selection: { suite: '', commit: '', machine: '', runs: [], runAgg: 'median' as const }, setSide: () => {}, label: 'Side A', }), @@ -954,8 +941,8 @@ describe('createMachineCombobox', () => { wrapper.remove(); }); - it('disables order input when machine is cleared via change', async () => { - const sideA: SideSelection = { suite: 'nts', order: '100', machine: 'clang-x86', runs: ['r1'], runAgg: 'median' }; + it('disables commit input when machine is cleared via change', async () => { + const sideA: SideSelection = { suite: 'nts', commit: '100', machine: 'clang-x86', runs: ['r1'], runAgg: 'median' }; const setSide = vi.fn((partial: Partial) => Object.assign(sideA, partial)); const onMachineChange = vi.fn(); const ctx = makeMachineCtx({ @@ -967,28 +954,28 @@ describe('createMachineCombobox', () => { }); const wrapper = await createAndLoad(ctx, setSide, onMachineChange); - // Create order combobox to set up orderInputA ref - const orderWrapper = createOrderCombobox('a', setSide, () => {}, ctx); - document.body.append(orderWrapper); - const orderInput = orderWrapper.querySelector('input')! as HTMLInputElement; - expect(orderInput.disabled).toBe(false); // machine is set + // Create commit combobox to set up commitInputA ref + const commitWrapper = createCommitCombobox('a', setSide, () => {}, ctx); + document.body.append(commitWrapper); + const commitInput = commitWrapper.querySelector('input')! as HTMLInputElement; + expect(commitInput.disabled).toBe(false); // machine is set // Clear machine text and trigger change const machineInput = wrapper.querySelector('input') as HTMLInputElement; machineInput.value = ''; machineInput.dispatchEvent(new Event('change')); - expect(setSide).toHaveBeenCalledWith({ machine: '', order: '', runs: [] }); - expect(orderInput.disabled).toBe(true); - expect(orderInput.placeholder).toBe('Select a machine first'); + expect(setSide).toHaveBeenCalledWith({ machine: '', commit: '', runs: [] }); + expect(commitInput.disabled).toBe(true); + expect(commitInput.placeholder).toBe('Select a machine first'); expect(onMachineChange).toHaveBeenCalled(); wrapper.remove(); - orderWrapper.remove(); + commitWrapper.remove(); }); it('disables machine input when no suite is selected', () => { - const sideA: SideSelection = { suite: '', order: '', machine: '', runs: [], runAgg: 'median' }; + const sideA: SideSelection = { suite: '', commit: '', machine: '', runs: [], runAgg: 'median' }; const ctx = makeMachineCtx({ getSuiteName: () => '', getSideState: () => ({ @@ -1025,27 +1012,27 @@ describe('createMachineCombobox', () => { }); // --------------------------------------------------------------------------- -// fetchMachineOrderSet tests +// fetchMachineCommitSet tests // --------------------------------------------------------------------------- -describe('fetchMachineOrderSet', () => { +describe('fetchMachineCommitSet', () => { beforeEach(() => { vi.clearAllMocks(); }); - it('returns set of primary order values from machine runs', async () => { + it('returns set of commit values from machine runs', async () => { (getMachineRuns as ReturnType).mockResolvedValue({ items: [ - { order: { rev: '100' }, uuid: 'r1', start_time: null, end_time: null }, - { order: { rev: '101' }, uuid: 'r2', start_time: null, end_time: null }, - { order: { rev: '100' }, uuid: 'r3', start_time: null, end_time: null }, + { commit: '100', uuid: 'r1', submitted_at: null }, + { commit: '101', uuid: 'r2', submitted_at: null }, + { commit: '100', uuid: 'r3', submitted_at: null }, ], cursor: { next: null }, }); - const orders = await fetchMachineOrderSet('nts', 'clang-x86'); + const commits = await fetchMachineCommitSet('nts', 'clang-x86'); - expect(orders).toEqual(new Set(['100', '101'])); + expect(commits).toEqual(new Set(['100', '101'])); expect(getMachineRuns).toHaveBeenCalledWith('nts', 'clang-x86', { limit: 500 }, undefined); }); @@ -1055,9 +1042,9 @@ describe('fetchMachineOrderSet', () => { cursor: { next: null }, }); - const orders = await fetchMachineOrderSet('nts', 'empty-machine'); + const commits = await fetchMachineCommitSet('nts', 'empty-machine'); - expect(orders).toEqual(new Set()); + expect(commits).toEqual(new Set()); }); it('passes abort signal to getMachineRuns', async () => { @@ -1067,7 +1054,7 @@ describe('fetchMachineOrderSet', () => { }); const ctrl = new AbortController(); - await fetchMachineOrderSet('nts', 'clang-x86', ctrl.signal); + await fetchMachineCommitSet('nts', 'clang-x86', ctrl.signal); expect(getMachineRuns).toHaveBeenCalledWith('nts', 'clang-x86', { limit: 500 }, ctrl.signal); }); diff --git a/lnt/server/ui/v5/frontend/src/__tests__/pages/compare.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/pages/compare.test.ts index aedc6a29a..65a998e51 100644 --- a/lnt/server/ui/v5/frontend/src/__tests__/pages/compare.test.ts +++ b/lnt/server/ui/v5/frontend/src/__tests__/pages/compare.test.ts @@ -4,7 +4,7 @@ import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; // Mock the API module before importing compare page vi.mock('../../api', () => ({ getFields: vi.fn(), - getOrders: vi.fn(), + getCommits: vi.fn(), getSamples: vi.fn(), getRuns: vi.fn(), getMachines: vi.fn(), @@ -29,18 +29,18 @@ const plotlyMock = { }; (globalThis as unknown as Record).Plotly = plotlyMock; -import { getFields, getOrders, getSamples, getMachines } from '../../api'; +import { getFields, getCommits, getSamples, getMachines } from '../../api'; import { getTestsuites } from '../../router'; import { comparePage } from '../../pages/compare'; -import type { FieldInfo, OrderSummary, SampleInfo } from '../../types'; +import type { FieldInfo, CommitSummary, SampleInfo } from '../../types'; const mockFields: FieldInfo[] = [ { name: 'exec_time', type: 'Real', display_name: 'Execution Time', unit: 's', unit_abbrev: 's', bigger_is_better: false }, ]; -const mockOrders: OrderSummary[] = [ - { fields: { rev: '100' }, tag: null }, - { fields: { rev: '101' }, tag: null }, +const mockCommits: CommitSummary[] = [ + { commit: '100', ordinal: null, fields: {} }, + { commit: '101', ordinal: null, fields: {} }, ]; const mockSamples: SampleInfo[] = [ @@ -53,7 +53,7 @@ const savedLocation = window.location; function setupMocks(): void { (getTestsuites as ReturnType).mockReturnValue(['nts']); (getFields as ReturnType).mockResolvedValue(mockFields); - (getOrders as ReturnType).mockResolvedValue(mockOrders); + (getCommits as ReturnType).mockResolvedValue(mockCommits); (getSamples as ReturnType).mockResolvedValue(mockSamples); (getMachines as ReturnType).mockResolvedValue({ items: [] }); } @@ -81,17 +81,17 @@ describe('comparePage', () => { (window as Record).location = savedLocation; }); - it('mount loads fields and orders for side with suite in URL', async () => { + it('mount loads fields and commits for side with suite in URL', async () => { comparePage.mount(container, { testsuite: '' }); // fetchSideData is called for side A because suite_a=nts is in the URL await vi.waitFor(() => { expect(getFields).toHaveBeenCalledWith('nts'); - expect(getOrders).toHaveBeenCalledWith('nts'); + expect(getCommits).toHaveBeenCalledWith('nts'); }); }); - it('shows error when fields/orders fetch fails', async () => { + it('shows error when fields/commits fetch fails', async () => { (getFields as ReturnType).mockRejectedValue(new Error('Network error')); comparePage.mount(container, { testsuite: '' }); diff --git a/lnt/server/ui/v5/frontend/src/__tests__/pages/graph.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/pages/graph.test.ts index 3fa39f7a4..a6a6a4745 100644 --- a/lnt/server/ui/v5/frontend/src/__tests__/pages/graph.test.ts +++ b/lnt/server/ui/v5/frontend/src/__tests__/pages/graph.test.ts @@ -25,7 +25,7 @@ vi.mock('../../components/machine-combobox', () => ({ renderMachineCombobox: vi.fn(() => mockMachineComboHandle), })); -const mockOrderPickerHandle = { +const mockCommitPickerHandle = { element: document.createElement('div'), input: document.createElement('input'), destroy: vi.fn(), @@ -34,8 +34,8 @@ vi.mock('../../combobox', async (importOriginal) => { const actual = await importOriginal(); return { ...actual, - createOrderPicker: vi.fn(() => mockOrderPickerHandle), - fetchMachineOrderSet: vi.fn().mockResolvedValue(new Set()), + createCommitPicker: vi.fn(() => mockCommitPickerHandle), + fetchMachineCommitSet: vi.fn().mockResolvedValue(new Set()), }; }); @@ -463,8 +463,8 @@ describe('graphPage mount', () => { container = document.createElement('div'); // Reset mock picker handle element (consumed by append) - mockOrderPickerHandle.element = document.createElement('div'); - mockOrderPickerHandle.input = document.createElement('input'); + mockCommitPickerHandle.element = document.createElement('div'); + mockCommitPickerHandle.input = document.createElement('input'); // Reset URL state delete (window as Record).location; diff --git a/lnt/server/ui/v5/frontend/src/__tests__/selection.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/selection.test.ts index 9e858c18e..764768a03 100644 --- a/lnt/server/ui/v5/frontend/src/__tests__/selection.test.ts +++ b/lnt/server/ui/v5/frontend/src/__tests__/selection.test.ts @@ -4,11 +4,11 @@ import { describe, it, expect, beforeEach, vi } from 'vitest'; // Mock the API module vi.mock('../api', () => ({ getFields: vi.fn(), - getOrders: vi.fn(), + getCommits: vi.fn(), getRuns: vi.fn(), })); -import { getFields, getOrders } from '../api'; +import { getFields, getCommits } from '../api'; import { initSelection, fetchSideData, getMetricFields } from '../selection'; import type { FieldInfo } from '../types'; @@ -29,7 +29,7 @@ describe('getMetricFields', () => { initSelection(['test-suite']); // Default: both API calls resolve with empty data (getFields as ReturnType).mockResolvedValue([]); - (getOrders as ReturnType).mockResolvedValue([]); + (getCommits as ReturnType).mockResolvedValue([]); }); it('returns only Real-typed fields', async () => { diff --git a/lnt/server/ui/v5/frontend/src/combobox.ts b/lnt/server/ui/v5/frontend/src/combobox.ts index 595ccfdae..97adf0b90 100644 --- a/lnt/server/ui/v5/frontend/src/combobox.ts +++ b/lnt/server/ui/v5/frontend/src/combobox.ts @@ -2,22 +2,21 @@ import type { SideSelection, MachineInfo } from './types'; import { getMachines, getMachineRuns } from './api'; import { el } from './utils'; -// Per-side machine order filtering -let machineOrdersA: Set | null = null; -let machineOrdersB: Set | null = null; -let orderInputA: HTMLInputElement | null = null; -let orderInputB: HTMLInputElement | null = null; +// Per-side machine commit filtering +let machineCommitsA: Set | null = null; +let machineCommitsB: Set | null = null; +let commitInputA: HTMLInputElement | null = null; +let commitInputB: HTMLInputElement | null = null; -// Per-side AbortControllers for machine-order fetches -let machineOrdersControllerA: AbortController | null = null; -let machineOrdersControllerB: AbortController | null = null; +// Per-side AbortControllers for machine-commit fetches +let machineCommitsControllerA: AbortController | null = null; +let machineCommitsControllerB: AbortController | null = null; /** Shared state that the combobox module reads but does not own. */ export interface ComboboxContext { - /** Get per-side order values and tags. */ - getOrderData: (side: 'a' | 'b') => { - cachedOrderValues: string[]; - orderTags: Map; + /** Get per-side commit values. */ + getCommitData: (side: 'a' | 'b') => { + cachedCommitValues: string[]; }; /** Get the testsuite name for a given side. */ getSuiteName: (side: 'a' | 'b') => string; @@ -30,57 +29,54 @@ export interface ComboboxContext { /** Reset per-panel mutable state. Call this at the start of renderSelectionPanel. */ export function resetComboboxState(): void { - machineOrdersA = null; - machineOrdersB = null; - orderInputA = null; - orderInputB = null; - if (machineOrdersControllerA) { machineOrdersControllerA.abort(); machineOrdersControllerA = null; } - if (machineOrdersControllerB) { machineOrdersControllerB.abort(); machineOrdersControllerB = null; } + machineCommitsA = null; + machineCommitsB = null; + commitInputA = null; + commitInputB = null; + if (machineCommitsControllerA) { machineCommitsControllerA.abort(); machineCommitsControllerA = null; } + if (machineCommitsControllerB) { machineCommitsControllerB.abort(); machineCommitsControllerB = null; } } /** - * Fetch the set of order values for a given machine. - * Returns a Set of primary order values extracted from the machine's runs. - * Reusable by any consumer that needs machine-filtered orders. + * Fetch the set of commit values for a given machine. + * Returns a Set of commit strings extracted from the machine's runs. + * Reusable by any consumer that needs machine-filtered commits. */ -export async function fetchMachineOrderSet( +export async function fetchMachineCommitSet( testsuite: string, machine: string, signal?: AbortSignal, ): Promise> { const page = await getMachineRuns(testsuite, machine, { limit: 500 }, signal); - const orders = new Set(); + const commits = new Set(); for (const run of page.items) { - const keys = Object.keys(run.order); - if (keys.length > 0) { - orders.add(run.order[keys[0]]); - } + commits.add(run.commit); } - return orders; + return commits; } -async function fetchMachineOrders( +async function fetchMachineCommits( side: 'a' | 'b', machine: string, testsuite: string, ): Promise { // Abort any in-flight request for this side only - const prev = side === 'a' ? machineOrdersControllerA : machineOrdersControllerB; + const prev = side === 'a' ? machineCommitsControllerA : machineCommitsControllerB; if (prev) prev.abort(); const ctrl = new AbortController(); - if (side === 'a') machineOrdersControllerA = ctrl; - else machineOrdersControllerB = ctrl; + if (side === 'a') machineCommitsControllerA = ctrl; + else machineCommitsControllerB = ctrl; try { - const orders = await fetchMachineOrderSet(testsuite, machine, ctrl.signal); - if (side === 'a') machineOrdersA = orders; - else machineOrdersB = orders; + const commits = await fetchMachineCommitSet(testsuite, machine, ctrl.signal); + if (side === 'a') machineCommitsA = commits; + else machineCommitsB = commits; } catch (err: unknown) { // Silently ignore aborted requests — a newer one superseded this if (err instanceof DOMException && err.name === 'AbortError') return; - // On other errors, don't filter orders - if (side === 'a') machineOrdersA = null; - else machineOrdersB = null; + // On other errors, don't filter commits + if (side === 'a') machineCommitsA = null; + else machineCommitsB = null; } } @@ -129,32 +125,32 @@ function setupComboboxKeyboard( } // --------------------------------------------------------------------------- -// createOrderPicker — reusable order combobox +// createCommitPicker — reusable commit combobox // --------------------------------------------------------------------------- -export interface OrderPickerOptions { +export interface CommitPickerOptions { id: string; - /** Called on each dropdown open/filter to get the current order data. + /** Called on each dropdown open/filter to get the current commit data. * Lazy evaluation ensures data fetched after picker creation is visible. */ - getOrderData: () => { values: string[]; tags: Map }; + getCommitData: () => { values: string[] }; initialValue?: string; placeholder?: string; onSelect: (value: string) => void; - /** Called on each dropdown render to get the machine-order filter state. - * - Return a Set to filter orders by machine. - * - Return 'loading' to show a loading hint (machine selected, orders not yet fetched). - * - Return null (or omit) to disable filtering (show all orders). */ - getMachineOrders?: () => Set | 'loading' | null; + /** Called on each dropdown render to get the machine-commit filter state. + * - Return a Set to filter commits by machine. + * - Return 'loading' to show a loading hint (machine selected, commits not yet fetched). + * - Return null (or omit) to disable filtering (show all commits). */ + getMachineCommits?: () => Set | 'loading' | null; } -export interface OrderPickerHandle { +export interface CommitPickerHandle { element: HTMLElement; input: HTMLInputElement; destroy: () => void; } -export function createOrderPicker(opts: OrderPickerOptions): OrderPickerHandle { - const dropdownId = `order-dropdown-${opts.id}`; +export function createCommitPicker(opts: CommitPickerOptions): CommitPickerHandle { + const dropdownId = `commit-dropdown-${opts.id}`; const wrapper = el('div', { class: 'combobox', role: 'combobox', @@ -163,7 +159,7 @@ export function createOrderPicker(opts: OrderPickerOptions): OrderPickerHandle { }); const input = el('input', { type: 'text', - placeholder: opts.placeholder || 'Type to search orders...', + placeholder: opts.placeholder || 'Type to search commits...', class: 'combobox-input', role: 'searchbox', 'aria-autocomplete': 'list', @@ -178,20 +174,18 @@ export function createOrderPicker(opts: OrderPickerOptions): OrderPickerHandle { // Keyboard navigation setupComboboxKeyboard(input, dropdown, wrapper); - // Set initial value with tag if available + // Set initial value if (opts.initialValue) { - const { tags } = opts.getOrderData(); - const tag = tags.get(opts.initialValue); - input.value = tag ? `${opts.initialValue} (${tag})` : opts.initialValue; + input.value = opts.initialValue; } function showDropdown(filter: string): void { - const machineOrders = opts.getMachineOrders?.() ?? null; + const machineCommits = opts.getMachineCommits?.() ?? null; - // Machine selected but orders not yet fetched — show loading hint. - if (machineOrders === 'loading') { + // Machine selected but commits not yet fetched — show loading hint. + if (machineCommits === 'loading') { dropdown.replaceChildren( - el('li', { class: 'combobox-item', style: 'color: #999; pointer-events: none' }, 'Loading orders...'), + el('li', { class: 'combobox-item', style: 'color: #999; pointer-events: none' }, 'Loading commits...'), ); dropdown.classList.add('open'); setAriaExpanded(wrapper, true); @@ -199,28 +193,22 @@ export function createOrderPicker(opts: OrderPickerOptions): OrderPickerHandle { return; } - const { values, tags } = opts.getOrderData(); + const { values } = opts.getCommitData(); let source = values; - if (machineOrders instanceof Set) { - source = source.filter(v => machineOrders.has(v)); + if (machineCommits instanceof Set) { + source = source.filter(v => machineCommits.has(v)); } const lf = filter.toLowerCase(); const matches = filter - ? source.filter(v => { - if (v.toLowerCase().includes(lf)) return true; - const tag = tags.get(v); - return tag !== null && tag !== undefined && tag.toLowerCase().includes(lf); - }) + ? source.filter(v => v.toLowerCase().includes(lf)) : source; const limited = matches.slice(0, 100); dropdown.replaceChildren(); for (const v of limited) { - const tag = tags.get(v); - const label = tag ? `${v} (${tag})` : v; - const li = el('li', { class: 'combobox-item', role: 'option', tabindex: '-1' }, label); + const li = el('li', { class: 'combobox-item', role: 'option', tabindex: '-1' }, v); li.addEventListener('click', () => { - input.value = label; + input.value = v; input.classList.remove('combobox-invalid'); dropdown.classList.remove('open'); setAriaExpanded(wrapper, false); @@ -232,7 +220,7 @@ export function createOrderPicker(opts: OrderPickerOptions): OrderPickerHandle { dropdown.classList.toggle('open', isOpen); setAriaExpanded(wrapper, isOpen); - // Show/hide validation halo based on whether any orders match + // Show/hide validation halo based on whether any commits match if (input.value.trim() && matches.length === 0) { input.classList.add('combobox-invalid'); } else { @@ -240,12 +228,12 @@ export function createOrderPicker(opts: OrderPickerOptions): OrderPickerHandle { } } - /** Check if a value is an exact match against available order values. */ - function isValidOrder(raw: string): boolean { - const { values } = opts.getOrderData(); - const machineOrders = opts.getMachineOrders?.() ?? null; - const source = machineOrders instanceof Set - ? values.filter(v => machineOrders.has(v)) + /** Check if a value is an exact match against available commit values. */ + function isValidCommit(raw: string): boolean { + const { values } = opts.getCommitData(); + const machineCommits = opts.getMachineCommits?.() ?? null; + const source = machineCommits instanceof Set + ? values.filter(v => machineCommits.has(v)) : values; return source.includes(raw); } @@ -258,7 +246,7 @@ export function createOrderPicker(opts: OrderPickerOptions): OrderPickerHandle { if (input.classList.contains('combobox-invalid')) return; const raw = input.value.replace(/\s*\(.*\)$/, '').trim(); if (!raw) return; - if (!isValidOrder(raw)) { + if (!isValidCommit(raw)) { input.classList.add('combobox-invalid'); return; } @@ -273,11 +261,11 @@ export function createOrderPicker(opts: OrderPickerOptions): OrderPickerHandle { setAriaExpanded(wrapper, false); }); input.addEventListener('change', () => { - // Strip tag suffix if present (e.g., "abc123 (release-1)" -> "abc123") + // Strip any trailing parenthetical if present if (input.classList.contains('combobox-invalid')) return; const raw = input.value.replace(/\s*\(.*\)$/, '').trim(); if (!raw) { opts.onSelect(raw); return; } - if (!isValidOrder(raw)) { + if (!isValidCommit(raw)) { input.classList.add('combobox-invalid'); return; } @@ -292,42 +280,42 @@ export function createOrderPicker(opts: OrderPickerOptions): OrderPickerHandle { } // --------------------------------------------------------------------------- -// createOrderCombobox — Compare page wrapper around createOrderPicker +// createCommitCombobox — Compare page wrapper around createCommitPicker // --------------------------------------------------------------------------- -export function createOrderCombobox( +export function createCommitCombobox( side: 'a' | 'b', setSide: (partial: Partial) => void, - onOrderChange: () => void, + onCommitChange: () => void, ctx: ComboboxContext, ): HTMLElement { const { selection } = ctx.getSideState(side); - const picker = createOrderPicker({ - id: `order-${side}`, - getOrderData: () => { - const { cachedOrderValues, orderTags } = ctx.getOrderData(side); - return { values: cachedOrderValues, tags: orderTags }; + const picker = createCommitPicker({ + id: `commit-${side}`, + getCommitData: () => { + const { cachedCommitValues } = ctx.getCommitData(side); + return { values: cachedCommitValues }; }, - initialValue: selection.order, - placeholder: 'Type to search orders...', + initialValue: selection.commit, + placeholder: 'Type to search commits...', onSelect: (value) => { - setSide(value ? { order: value } : { order: '', runs: [] }); - onOrderChange(); + setSide(value ? { commit: value } : { commit: '', runs: [] }); + onCommitChange(); }, - getMachineOrders: () => { - const orders = side === 'a' ? machineOrdersA : machineOrdersB; - if (orders) return orders; + getMachineCommits: () => { + const commits = side === 'a' ? machineCommitsA : machineCommitsB; + if (commits) return commits; const { selection: s } = ctx.getSideState(side); return s.machine ? 'loading' : null; }, }); // Store refs for createMachineCombobox interaction - if (side === 'a') orderInputA = picker.input; - else orderInputB = picker.input; + if (side === 'a') commitInputA = picker.input; + else commitInputB = picker.input; - // Disable order input until a machine is selected + // Disable commit input until a machine is selected if (!selection.machine) { picker.input.disabled = true; picker.input.placeholder = 'Select a machine first'; @@ -369,26 +357,26 @@ export function createMachineCombobox( const { selection } = ctx.getSideState(side); if (selection.machine) { input.value = selection.machine; - // Pre-fetch orders for URL-restored machine so the order dropdown - // is correctly filtered from the start (not showing all orders). - fetchMachineOrders(side, selection.machine, ctx.getSuiteName(side)); + // Pre-fetch commits for URL-restored machine so the commit dropdown + // is correctly filtered from the start (not showing all commits). + fetchMachineCommits(side, selection.machine, ctx.getSuiteName(side)); } async function onMachineSelect(name: string): Promise { setSide({ machine: name }); - await fetchMachineOrders(side, name, ctx.getSuiteName(side)); - // Clear order if it's no longer valid for this machine - const machineOrders = side === 'a' ? machineOrdersA : machineOrdersB; + await fetchMachineCommits(side, name, ctx.getSuiteName(side)); + // Clear commit if it's no longer valid for this machine + const machineCommits = side === 'a' ? machineCommitsA : machineCommitsB; const { selection: current } = ctx.getSideState(side); - if (machineOrders && current.order && !machineOrders.has(current.order)) { - setSide({ order: '' }); + if (machineCommits && current.commit && !machineCommits.has(current.commit)) { + setSide({ commit: '' }); } - const orderInput = side === 'a' ? orderInputA : orderInputB; - if (orderInput) { - orderInput.disabled = false; - orderInput.placeholder = 'Type to search orders...'; + const commitInput = side === 'a' ? commitInputA : commitInputB; + if (commitInput) { + commitInput.disabled = false; + commitInput.placeholder = 'Type to search commits...'; const { selection: updated } = ctx.getSideState(side); - orderInput.value = updated.order || ''; + commitInput.value = updated.commit || ''; } onMachineChange(); } @@ -477,13 +465,13 @@ export function createMachineCombobox( input.addEventListener('change', () => { const text = input.value.trim(); if (!text) { - // Machine cleared — reset downstream state and disable order - setSide({ machine: '', order: '', runs: [] }); - const orderInput = side === 'a' ? orderInputA : orderInputB; - if (orderInput) { - orderInput.disabled = true; - orderInput.placeholder = 'Select a machine first'; - orderInput.value = ''; + // Machine cleared — reset downstream state and disable commit + setSide({ machine: '', commit: '', runs: [] }); + const commitInput = side === 'a' ? commitInputA : commitInputB; + if (commitInput) { + commitInput.disabled = true; + commitInput.placeholder = 'Select a machine first'; + commitInput.value = ''; } input.classList.remove('combobox-invalid'); onMachineChange(); diff --git a/lnt/server/ui/v5/frontend/src/pages/compare.ts b/lnt/server/ui/v5/frontend/src/pages/compare.ts index 11b0895d3..b3e9213a9 100644 --- a/lnt/server/ui/v5/frontend/src/pages/compare.ts +++ b/lnt/server/ui/v5/frontend/src/pages/compare.ts @@ -6,7 +6,7 @@ // // Per-run sample caching: fetched samples are cached by run UUID. Changing the // metric, aggregation, or noise re-aggregates from cache without API calls. -// Only new run UUIDs (from order/machine changes) trigger fetches. +// Only new run UUIDs (from commit/machine changes) trigger fetches. // // Cross-suite support: each side can independently select a test suite. // Samples are fetched from the side's suite. The comparison joins on test name. diff --git a/lnt/server/ui/v5/frontend/src/pages/graph.ts b/lnt/server/ui/v5/frontend/src/pages/graph.ts index 876eb95e5..75671591b 100644 --- a/lnt/server/ui/v5/frontend/src/pages/graph.ts +++ b/lnt/server/ui/v5/frontend/src/pages/graph.ts @@ -8,7 +8,7 @@ import { getTestsuites } from '../router'; import { onCustomEvent, GRAPH_TABLE_HOVER, GRAPH_CHART_HOVER } from '../events'; import { renderMachineCombobox } from '../components/machine-combobox'; import { renderMetricSelector, renderEmptyMetricSelector, filterMetricFields } from '../components/metric-selector'; -import { createOrderPicker, fetchMachineOrderSet } from '../combobox'; +import { createCommitPicker, fetchMachineCommitSet } from '../combobox'; import { type TimeSeriesTrace, type PinnedBaseline, type ChartHandle, createTimeSeriesChart, @@ -332,24 +332,24 @@ export const graphPage: PageModule = { baselineCommitCache.set(suite, []); } })(); - const machineOrdersPromise = fetchMachineOrderSet(suite, name) + const machineOrdersPromise = fetchMachineCommitSet(suite, name) .catch(() => null as Set | null); await commitListPromise; // Create order picker with machine-commit filtering - const picker = createOrderPicker({ + const picker = createCommitPicker({ id: 'baseline-order', - getOrderData: () => { + getCommitData: () => { const values = baselineCommitCache.get(suite); - return { cachedOrderValues: values ?? null, orderTags: new Map() }; + return { values: values ?? [] }; }, - placeholder: 'Type to search orders...', + placeholder: 'Type to search commits...', onSelect: (value) => { blSelectedCommit = value; addCurrentBaseline(); }, - getMachineOrders: () => blSelectedMachine ? (blMachineCommits ?? 'loading') : null, + getMachineCommits: () => blSelectedMachine ? (blMachineCommits ?? 'loading') : null, }); blCommitContainer.append(picker.element); blCommitCleanup = picker.destroy; diff --git a/lnt/server/ui/v5/frontend/src/selection.ts b/lnt/server/ui/v5/frontend/src/selection.ts index 8c21f421d..2c1bf9a66 100644 --- a/lnt/server/ui/v5/frontend/src/selection.ts +++ b/lnt/server/ui/v5/frontend/src/selection.ts @@ -1,18 +1,18 @@ -import type { AggFn, FieldInfo, OrderSummary, SideSelection } from './types'; +import type { AggFn, FieldInfo, CommitSummary, SideSelection } from './types'; import { SETTINGS_CHANGE, TEST_FILTER_CHANGE } from './events'; -import { getFields, getOrders, getRuns } from './api'; +import { getFields, getCommits, getRuns } from './api'; import { getBasePath } from './router'; import { getState, setSideA, setSideB, setState, swapSides } from './state'; import { debounce, el } from './utils'; import { - createOrderCombobox, createMachineCombobox, resetComboboxState, + createCommitCombobox, createMachineCombobox, resetComboboxState, type ComboboxContext, } from './combobox'; import { renderMetricSelector, renderEmptyMetricSelector, filterMetricFields } from './components/metric-selector'; // Per-side cached data -let cachedOrdersA: OrderSummary[] = []; -let cachedOrdersB: OrderSummary[] = []; +let cachedCommitsA: CommitSummary[] = []; +let cachedCommitsB: CommitSummary[] = []; let cachedFieldsA: FieldInfo[] = []; let cachedFieldsB: FieldInfo[] = []; let testsuites: string[] = []; @@ -41,8 +41,8 @@ export function initSelection( ): void { testsuites = availableTestsuites; if (compareFn) onCompare = compareFn; - cachedOrdersA = []; - cachedOrdersB = []; + cachedCommitsA = []; + cachedCommitsB = []; cachedFieldsA = []; cachedFieldsB = []; } @@ -69,24 +69,15 @@ function getSideState(side: 'a' | 'b') { }; } -function getOrderDataForSide(side: 'a' | 'b') { - const orders = side === 'a' ? cachedOrdersA : cachedOrdersB; - const cachedOrderValues: string[] = []; - const orderTags = new Map(); - for (const o of orders) { - const keys = Object.keys(o.fields); - if (keys.length > 0) { - const v = o.fields[keys[0]]; - cachedOrderValues.push(v); - orderTags.set(v, o.tag ?? null); - } - } - return { cachedOrderValues, orderTags }; +function getCommitDataForSide(side: 'a' | 'b') { + const commits = side === 'a' ? cachedCommitsA : cachedCommitsB; + const cachedCommitValues = commits.map(c => c.commit); + return { cachedCommitValues }; } function getComboboxContext(): ComboboxContext { return { - getOrderData: getOrderDataForSide, + getCommitData: getCommitDataForSide, getSuiteName: (side: 'a' | 'b') => { const { selection } = getSideState(side); return selection.suite; @@ -120,14 +111,14 @@ function createRunsPanel(side: 'a' | 'b', container: HTMLElement, setSide: (part const { selection: sideState } = getSideState(side); - if (!sideState.suite || !sideState.order || !sideState.machine) { - container.replaceChildren(el('span', { class: 'runs-hint' }, 'Select an order first')); + if (!sideState.suite || !sideState.commit || !sideState.machine) { + container.replaceChildren(el('span', { class: 'runs-hint' }, 'Select a commit first')); return; } container.replaceChildren(el('span', { class: 'runs-loading' }, 'Loading runs...')); - getRuns(sideState.suite, { machine: sideState.machine, order: sideState.order }) + getRuns(sideState.suite, { machine: sideState.machine, commit: sideState.commit }) .then(runs => { // A newer createRunsPanel call was made while we were waiting — // discard this stale result to avoid overwriting fresh data. @@ -150,7 +141,7 @@ function createRunsPanel(side: 'a' | 'b', container: HTMLElement, setSide: (part const cb = el('input', { type: 'checkbox', id, value: run.uuid }); cb.checked = hasUrlMatch ? urlRuns.has(run.uuid) : true; const label = el('label', { for: id }, - run.start_time ? new Date(run.start_time).toLocaleString() : '(no time)', + run.submitted_at ? new Date(run.submitted_at).toLocaleString() : '(no time)', ); const link = el('a', { href: `${getBasePath()}/${encodeURIComponent(sideState.suite)}/runs/${encodeURIComponent(run.uuid)}`, @@ -234,9 +225,9 @@ export async function fetchSideData( const version = side === 'a' ? ++suiteLoadVersionA : ++suiteLoadVersionB; try { - const [fields, orders] = await Promise.all([ + const [fields, commits] = await Promise.all([ getFields(suite), - getOrders(suite), + getCommits(suite), ]); // Check for staleness @@ -245,10 +236,10 @@ export async function fetchSideData( if (side === 'a') { cachedFieldsA = fields; - cachedOrdersA = orders; + cachedCommitsA = commits; } else { cachedFieldsB = fields; - cachedOrdersB = orders; + cachedCommitsB = commits; } // Re-render metric selector — read metricContainerRef AFTER await @@ -312,13 +303,13 @@ export function renderSelectionPanel(root: HTMLElement): void { } suiteSelect.addEventListener('change', () => { const newSuite = suiteSelect.value; - setSide({ suite: newSuite, machine: '', order: '', runs: [] }); + setSide({ suite: newSuite, machine: '', commit: '', runs: [] }); if (newSuite) { fetchSideData(side, newSuite); } else { // Clear cached data for this side so metrics/orders don't linger - if (side === 'a') { cachedFieldsA = []; cachedOrdersA = []; } - else { cachedFieldsB = []; cachedOrdersB = []; } + if (side === 'a') { cachedFieldsA = []; cachedCommitsA = []; } + else { cachedFieldsB = []; cachedCommitsB = []; } } // Re-render the panel to update comboboxes with new suite context renderSelectionPanel(root); @@ -337,7 +328,7 @@ export function renderSelectionPanel(root: HTMLElement): void { // Order sideDiv.append(el('label', {}, 'Order')); - sideDiv.append(createOrderCombobox(side, setSide, refreshRuns, ctx)); + sideDiv.append(createCommitCombobox(side, setSide, refreshRuns, ctx)); // Runs sideDiv.append(el('label', {}, 'Runs')); @@ -361,9 +352,9 @@ export function renderSelectionPanel(root: HTMLElement): void { swapBtn.addEventListener('click', () => { swapSides(); // Also swap per-side caches - const tmpOrders = cachedOrdersA; - cachedOrdersA = cachedOrdersB; - cachedOrdersB = tmpOrders; + const tmpCommits = cachedCommitsA; + cachedCommitsA = cachedCommitsB; + cachedCommitsB = tmpCommits; const tmpFields = cachedFieldsA; cachedFieldsA = cachedFieldsB; cachedFieldsB = tmpFields; From cbaec71e941b92573e2eb2f8b9803ee4da0bfe45 Mon Sep 17 00:00:00 2001 From: Louis Dionne Date: Tue, 14 Apr 2026 18:06:25 -0400 Subject: [PATCH 059/143] [UI] Final cleanup of stale Order references and design doc sync Clean up remaining stale comments, variable names, CSS classes, mock data shapes, admin page schema labels, and Python route test. Update v5-ui.md design doc to use Commit terminology throughout. Co-Authored-By: Claude Opus 4.6 (1M context) --- docs/design/v5-ui.md | 96 +++++++++---------- .../ui/v5/frontend/src/__tests__/api.test.ts | 4 +- .../src/__tests__/pages/admin.test.ts | 4 +- .../__tests__/pages/graph-data-cache.test.ts | 4 +- .../src/__tests__/pages/graph.test.ts | 16 ++-- .../frontend/src/__tests__/pages/home.test.ts | 12 +-- .../src/__tests__/time-series-chart.test.ts | 6 +- lnt/server/ui/v5/frontend/src/pages/admin.ts | 8 +- lnt/server/ui/v5/frontend/src/pages/graph.ts | 14 +-- lnt/server/ui/v5/frontend/src/pages/home.ts | 2 +- lnt/server/ui/v5/frontend/src/selection.ts | 6 +- lnt/server/ui/v5/frontend/src/style.css | 6 +- tests/server/ui/v5/test_spa_shell.py | 4 +- 13 files changed, 91 insertions(+), 91 deletions(-) diff --git a/docs/design/v5-ui.md b/docs/design/v5-ui.md index e70353fc5..a33076902 100644 --- a/docs/design/v5-ui.md +++ b/docs/design/v5-ui.md @@ -67,7 +67,7 @@ The shell template (`v5_app.html`) is a standalone HTML page (it does NOT extend /v5/{ts}/ Suite root (redirects to /v5/test-suites?suite={ts}) /v5/{ts}/machines/{name} Machine Detail /v5/{ts}/runs/{uuid} Run Detail -/v5/{ts}/orders/{value} Order Detail +/v5/{ts}/commits/{value} Commit Detail /v5/{ts}/regressions?state=... Regression List /v5/{ts}/regressions/{uuid} Regression Detail /v5/{ts}/field-changes Field Change Triage @@ -105,7 +105,7 @@ Suite-agnostic landing page providing an at-a-glance visual overview of performa **Sparkline cards**: - Each card shows a small time-series chart (~300×160px) with the metric name (and unit, if available) as the card title. - Up to 5 traces per chart, one per most-recently-active machine (determined from recent runs sorted by start_time). Each trace is a colored line. -- X-axis: run timestamps. Y-axis: geometric mean of all test values at each order for that machine+metric combination. +- X-axis: run timestamps. Y-axis: geometric mean of all test values at each commit for that machine+metric combination. - Hover tooltip shows the value and machine name. - Clicking a sparkline navigates to the Graph page pre-populated with that suite, metric, and the displayed machines. Clicking directly on a specific trace navigates with just that machine. - Loading state: placeholder skeleton while data is being fetched. @@ -116,7 +116,7 @@ Suite-agnostic landing page providing an at-a-glance visual overview of performa **Data flow**: 1. Suite names from `getTestsuites()` (embedded in HTML shell, no API call). 2. Per suite: `getTestSuiteInfo()` for the metrics schema, `getRunsPage(sort=-start_time, limit=50)` to find the 5 most recently active machines. -3. Per suite×metric: `fetchTrends()` calls `POST /api/v5/{ts}/trends` with the metric, machine list, and `after_time` filter. The server groups all samples by (machine, order) and returns the geomean per group. The frontend groups the response by machine into `SparklineTrace[]`. +3. Per suite×metric: `fetchTrends()` calls `POST /api/v5/{ts}/trends` with the metric, machine list, and `after_time` filter. The server groups all samples by (machine, commit) and returns the geomean per group. The frontend groups the response by machine into `SparklineTrace[]`. 4. Sparklines render progressively as each metric's data arrives. **Geomean**: `exp(mean(ln(values)))`, skipping zero/negative values. Computed server-side in the trends endpoint. Shared utility in `utils.ts` also used by the Compare page. @@ -127,7 +127,7 @@ The primary entry point for browsing test suite data. Suite-agnostic page with a **Suite picker**: A row of prominent card/button elements, one per test suite (from `data-testsuites`). Clicking a card selects it (highlighted) and shows the tab bar below. When no suite is selected, only the suite picker is visible. -**Tabs**: [Recent Activity] [Machines] [Runs] [Orders]. Default tab is Recent Activity. +**Tabs**: [Recent Activity] [Machines] [Runs] [Commits]. Default tab is Recent Activity. **URL state**: `?suite={ts}&tab=machines&search=foo&offset=0` — all state is in query params. On mount, reads params to restore state. On changes, updates URL via `replaceState`. @@ -136,19 +136,19 @@ The primary entry point for browsing test suite data. Suite-agnostic page with a | Recent Activity | Last 25 runs sorted by time; "Load more" for next page | `GET runs?sort=-start_time&limit=25` | None | | Machines | Searchable machine list with offset pagination | `GET machines?name_contains=...&limit=25&offset=...` | Name substring | | Runs | Run list with cursor pagination | `GET runs?machine=...&sort=-start_time&limit=25` | Machine name (exact) | -| Orders | Order list with cursor pagination | `GET orders?tag_prefix=...&limit=25` | Tag prefix | +| Commits | Commit list with cursor pagination | `GET commits?tag_prefix=...&limit=25` | Tag prefix | **Columns per tab:** -- **Recent Activity**: Machine, Order (primary value), Start Time, UUID (truncated, linked) +- **Recent Activity**: Machine, Commit (primary value), Start Time, UUID (truncated, linked) - **Machines**: Name (linked), Info (key-value summary) -- **Runs**: UUID (truncated, linked), Machine, Order (primary value), Start Time -- **Orders**: Order Value (primary field, linked), Tag +- **Runs**: UUID (truncated, linked), Machine, Commit (primary value), Start Time +- **Commits**: Commit Value (primary field, linked), Tag **Detail navigation**: Clicking an item navigates to the full suite-scoped detail page (e.g., `/v5/{ts}/machines/{name}`) via full page navigation. This crosses from suite-agnostic context to suite-scoped context. **Suite root redirect**: `/v5/{ts}/` redirects to `/v5/test-suites?suite={ts}`. -**Links out**: Machine Detail, Run Detail, Order Detail. +**Links out**: Machine Detail, Run Detail, Commit Detail. ### 3. Machine Detail — `/v5/{ts}/machines/{name}` @@ -162,7 +162,7 @@ Deep dive into a single machine. Machine names are guaranteed unique. The delete section appears at the bottom. Clicking "Delete Machine" shows a confirmation prompt requiring the user to type the machine name. Deletion requires a valid API token with `manage` scope (set via the Settings panel in the nav bar). On success, navigates to the machine list. On auth failure (401/403), shows an error message reminding the user to set an API token with sufficient permissions. While the delete is in progress, a message reassures the user that deletion may take a while for machines with many runs. -**Links out**: Run Detail, Order Detail, Graph (with machine pre-filled), Compare (with machine pre-selected). +**Links out**: Run Detail, Commit Detail, Graph (with machine pre-filled), Compare (with machine pre-selected). ### 4. Run Detail — `/v5/{ts}/runs/{uuid}` @@ -170,7 +170,7 @@ All data from a single test execution. | Section | Shows | API Calls | |---------|-------|-----------| -| Metadata | Machine, order, start/end time, parameters | `GET runs/{uuid}` | +| Metadata | Machine, commit, start/end time, parameters | `GET runs/{uuid}` | | Metric Selector | Drop-down to choose which metric to display (like Compare page) | `GET test-suites/{ts}` (fields from `schema.metrics`) | | Test Filter | Text input for substring matching on test names | (client-side) | | Samples Table | All samples + selected metric value, sorted by test name by default | `GET runs/{uuid}/samples` | @@ -180,23 +180,23 @@ The metric selector drop-down controls which metric column is shown in the sampl Samples are loaded progressively — the table renders immediately with the first page and grows as more pages arrive, with a progress indicator showing the count. Multiple samples for the same test (repetitions) appear as separate rows. -A "Compare with..." button navigates to the Compare page with this run's machine and order pre-selected on side A, leaving side B open for the user to fill in. +A "Compare with..." button navigates to the Compare page with this run's machine and commit pre-selected on side A, leaving side B open for the user to fill in. The delete section appears at the bottom. Clicking "Delete Run" shows a confirmation prompt requiring the user to type the first 8 characters of the run UUID. Deletion requires a valid API token with `manage` scope. On success, navigates to the machine detail page. -**Links out**: Machine Detail, Order Detail, Graph (test pre-filled), Profile, Compare (side A pre-selected). +**Links out**: Machine Detail, Commit Detail, Graph (test pre-filled), Profile, Compare (side A pre-selected). -### 5. Order Detail — `/v5/{ts}/orders/{value}` +### 5. Commit Detail — `/v5/{ts}/commits/{value}` The "what happened at this commit?" page. Key investigation page for developers. -- Order field values displayed prominently -- **Tag display + editing**: Show the order's tag (if set) prominently next to the order field values (e.g., "Tag: release-18.1"). An inline edit button allows setting or clearing the tag. Editing requires an API token with `manage` scope (from Settings); show an auth error if the token is missing or insufficient. -- **Navigation**: Prev/Next buttons (using the API's `previous_order`/`next_order` from the order detail response) +- Commit field values displayed prominently +- **Tag display + editing**: Show the commit's tag (if set) prominently next to the commit field values (e.g., "Tag: release-18.1"). An inline edit button allows setting or clearing the tag. Editing requires an API token with `manage` scope (from Settings); show an auth error if the token is missing or insufficient. +- **Navigation**: Prev/Next buttons (using the API's `previous_commit`/`next_commit` from the commit detail response) - **Summary**: N runs across M machines - **Machine filter**: Text input for substring matching on machine names, filters the runs table. The summary updates to reflect filtered counts (e.g., "5 of 12 runs across 2 of 8 machines"). - **Runs table**: Columns: machine (link to Machine Detail), run UUID (link to Run Detail), start time -- API: `GET orders/{value}`, `PATCH orders/{value}` (tag editing), `GET runs?order={value}` +- API: `GET commits/{value}`, `PATCH commits/{value}` (tag editing), `GET runs?commit={value}` - **Links out**: Run Detail, Machine Detail ### 6. Graph (Time Series) — `/v5/graph?suite={ts}&machine={m}&metric={f}` @@ -206,44 +206,44 @@ The primary performance-over-time visualization. Replaces v4's graph page. This - **Suite selector**: A required dropdown at the top of the page, populated from the `data-testsuites` HTML attribute. All other controls (machine, metric, test filter, aggregation, baselines) are disabled until a suite is selected. Changing the suite clears the machine list, all caches, and the chart. When the page is loaded with `suite=` in the URL, the dropdown is pre-selected. - **Machine chip input**: The machine selector is a chip-based multi-select input. The user types a machine name (with typeahead suggestions) and presses Enter to add it. Each added machine appears as a chip with an × button to remove it. Multiple machines can be added to overlay their data on the same chart. Removing the last machine clears the chart. The metric selector is shared across all machines — the same metric is plotted for every machine. The full machine list is fetched once when the combobox is created and filtered locally by case-insensitive substring as the user types (instant, no per-keystroke API calls). A "Loading machines..." hint is shown until the initial fetch completes. -- **Input validation**: Machine and order comboboxes show a red halo (`.combobox-invalid` — red border + box-shadow) whenever the suggestion dropdown is empty, meaning no machine or order matches the typed text. Acceptance (Enter key, blur/change) is blocked while the halo is showing. The halo updates in real-time on every keystroke. Clicking a dropdown suggestion always clears the halo and accepts the value. For order comboboxes, acceptance via Enter or blur additionally requires an exact match against available order values — a partial substring match (e.g. typing "789" when the order is "566789") is rejected with the red halo even though suggestions are visible. All comboboxes support ArrowDown/ArrowUp keyboard navigation through suggestions, with Enter to select the focused item. +- **Input validation**: Machine and commit comboboxes show a red halo (`.combobox-invalid` — red border + box-shadow) whenever the suggestion dropdown is empty, meaning no machine or commit matches the typed text. Acceptance (Enter key, blur/change) is blocked while the halo is showing. The halo updates in real-time on every keystroke. Clicking a dropdown suggestion always clears the halo and accepts the value. For commit comboboxes, acceptance via Enter or blur additionally requires an exact match against available commit values — a partial substring match (e.g. typing "789" when the commit is "566789") is rejected with the red halo even though suggestions are visible. All comboboxes support ArrowDown/ArrowUp keyboard navigation through suggestions, with Enter to select the focused item. - **Explicit test selection**: There is no "Plot" button or auto-plot. When at least one machine and a metric are selected, the test table is populated with ALL matching tests (no cap). **Nothing is plotted by default** — the chart starts empty with the x-axis scaffold. The user explicitly selects which tests to plot by clicking rows in the test table. Data is fetched on-demand when tests are selected. The metric selector initially shows a "-- Select metric --" placeholder (no metric pre-selected), consistent with the Compare page. - **Multi-machine trace naming and symbols**: Each trace is named `{test name} - {machine name}` (test name first for natural sorting). Machines are visually distinguished by marker symbols: the first machine uses circles (default), the second triangles, then squares, diamonds, etc. Colors represent test identity, assigned by the test's position in the alphabetically sorted full test list (not just the selected subset). This ensures stable colors — adding or removing a selection does not shuffle existing colors. The same test on different machines shares the same color but has a different marker shape. - **Test filter**: A text filter (like the Compare page) that controls which tests appear in the test table. The filter matches on **test name only** (not machine name) via case-insensitive substring. Changing the filter prunes selected tests that no longer match — their traces are removed from the chart. Clearing the filter restores the full test list (previously selected tests remain selected if they match). -- **X-axis is always order** (not date — orders are not necessarily correlated to dates) -- Plotly line chart: metric value vs order, one trace per matching test +- **X-axis is always commit** (not date — commits are not necessarily correlated to dates) +- Plotly line chart: metric value vs commit, one trace per matching test - **Aggregation controls** (consistent with Compare page): - - Run aggregation: how to combine multiple runs at the same order (median/mean/min/max) + - Run aggregation: how to combine multiple runs at the same commit (median/mean/min/max) - Sample aggregation: how to combine multiple samples within a run (median/mean/min/max) - **Lazy loading with progressive rendering**: Data is fetched on-demand when tests are selected (not eagerly on discovery). For each selected test, data is fetched via `POST /query` with OR'd test names and rendered incrementally. When shift-clicking to select a range, the batch of tests is fetched in a single query. The chart progressively fills in data as pages arrive via cursor-based pagination. This avoids blocking the UI on large datasets. -- **X-axis scaffolding**: To prevent the x-axis from resizing/shifting as lazy-loaded pages arrive, the graph page pre-fetches the complete list of order values for each selected machine via paginated calls to the `GET machines/{name}/runs` endpoint (using `fetchOneCursorPage` with `sort=order`). When multiple machines are selected, the scaffold is the **union** of all machines' order values, so the x-axis spans the full range across all machines. Traces naturally have gaps where their machine has no data at a given order. Each machine's scaffold is fetched and cached independently; the union is recomputed when machines are added or removed. If a scaffold fetch fails for one machine, that machine's orders are simply not included in the union — the chart still works. +- **X-axis scaffolding**: To prevent the x-axis from resizing/shifting as lazy-loaded pages arrive, the graph page pre-fetches the complete list of commit values for each selected machine via paginated calls to the `GET machines/{name}/runs` endpoint (using `fetchOneCursorPage` with `sort=commit`). When multiple machines are selected, the scaffold is the **union** of all machines' commit values, so the x-axis spans the full range across all machines. Traces naturally have gaps where their machine has no data at a given commit. Each machine's scaffold is fetched and cached independently; the union is recomputed when machines are added or removed. If a scaffold fetch fails for one machine, that machine's commits are simply not included in the union — the chart still works. - **Incremental chart updates**: The chart component exposes a `ChartHandle` API (via `createTimeSeriesChart`) that supports incremental updates through `Plotly.react()` — the chart is updated in-place as new pages of data arrive, rather than being destroyed and re-created. - **Zoom preservation during progressive loading**: If the user zooms into the chart while data is still loading, the zoom is preserved across incremental updates. The x-axis range is always preserved (it was established by the scaffold or by user zoom). The y-axis range is preserved only when the user has explicitly zoomed; otherwise, it auto-ranges to accommodate new data as it arrives. Double-clicking the chart resets the zoom to the full range as usual. - **Test selection table**: Below the chart, a table lists ALL tests matching the current filter, sorted alphabetically by test name. One row per test name (not per test×machine combination — selecting a test plots it on all active machines). The table is part of the normal page flow (no scrollable container). A message line above the rows shows counts (e.g., "3 of 1200 tests selected" or "3 of 1200 tests selected, loading..."). Each row has: a checkbox cell (checked = selected/plotted), a symbol cell (colored marker character ●/▲/■ only when selected, empty otherwise), and the test name. The test filter narrows the table; tests that no longer match are pruned from the selection. - **Selection interactions**: A header "check all" checkbox in the table header selects or deselects all visible tests (tri-state: unchecked, indeterminate when some selected, checked when all selected). Clicking a row toggles its selection (and triggers data fetch if selecting). Shift-clicking selects a contiguous range from the last-clicked row (additive — adds to existing selection). Double-clicking isolates that test (deselects all others); double-clicking the sole selected test restores all (selects every visible test). Selected tests with data still loading show a loading indicator. Plotly's built-in legend is disabled; the table replaces it. Bidirectional hover highlighting: hovering a table row highlights the corresponding chart trace(s); hovering a chart trace highlights the table row. Selected tests are NOT persisted in the URL (test names can be very long); the filter, suite, machine, metric, aggregation, and baselines remain in the URL. - **Client-side caching and state persistence**: Test names, data points, scaffolds, and baseline data are cached locally. Test names are fetched once per machine/metric combination (all names, no server-side filter) and filtered client-side. Changing the test filter or aggregation mode re-renders instantly from cache without any additional API calls. Adding a second machine starts its own fetch pipeline while the first machine's data is already displayed. The cache, the selected test set, and the matching test list are all preserved across page unmount/remount, so navigating away and pressing browser back renders the previous selection and chart instantly from cache. All caches and selections are cleared on suite change. -- **Baselines**: Users can overlay one or more baselines as horizontal dashed lines on the chart. Each baseline is a (suite, machine, order) tuple, allowing cross-suite comparisons. The selector is an expandable panel with cascading dropdowns: Suite (populated from `data-testsuites`) → Machine (populated from the selected suite's machines endpoint) → Order (populated from the selected machine's orders). Added baselines appear as removable chips labeled `{suite}/{machine}/{order} ({tag})`. Baseline data is fetched from the baseline's suite via `POST /api/v5/{suite}/query` with `{machine, metric, order, test}` in the JSON body. Each baseline renders as a horizontal dashed line per test trace, spanning the full chart width, colored to match the corresponding test's main trace. The baseline's Y value for each test is computed using the same run aggregation function as the main trace (e.g., median of all runs at that order), so the dashed line aligns exactly with the trace point at that order. Hovering a dashed line shows a tooltip with: the baseline suite, machine, order value, tag (if set), test name, and metric value. Baselines are encoded in the URL query string for shareability (e.g., `&baseline=nts::machine1::abc123&baseline=other_suite::machine2::def456`). Baseline data is fetched asynchronously after the first render, so it does not block initial chart display. +- **Baselines**: Users can overlay one or more baselines as horizontal dashed lines on the chart. Each baseline is a (suite, machine, commit) tuple, allowing cross-suite comparisons. The selector is an expandable panel with cascading dropdowns: Suite (populated from `data-testsuites`) → Machine (populated from the selected suite's machines endpoint) → Commit (populated from the selected machine's commits). Added baselines appear as removable chips labeled `{suite}/{machine}/{commit} ({tag})`. Baseline data is fetched from the baseline's suite via `POST /api/v5/{suite}/query` with `{machine, metric, commit, test}` in the JSON body. Each baseline renders as a horizontal dashed line per test trace, spanning the full chart width, colored to match the corresponding test's main trace. The baseline's Y value for each test is computed using the same run aggregation function as the main trace (e.g., median of all runs at that commit), so the dashed line aligns exactly with the trace point at that commit. Hovering a dashed line shows a tooltip with: the baseline suite, machine, commit value, tag (if set), test name, and metric value. Baselines are encoded in the URL query string for shareability (e.g., `&baseline=nts::machine1::abc123&baseline=other_suite::machine2::def456`). Baseline data is fetched asynchronously after the first render, so it does not block initial chart display. - **Concurrent background fetches**: Each machine×metric fetch uses its own AbortController, so navigating away or removing a machine cancels its in-flight requests cleanly without affecting other machines' fetches. -- **Hover** a data point: tooltip showing test name, machine name, order value, aggregated metric value, run count. Hover distance is reduced (`hoverdistance: 5`, less sticky tooltips) so the tooltip only appears when the cursor is close to a data point. When hovering over an aggregated point that represents multiple runs, the individual pre-aggregation values are shown as a scatter of markers at the same x-position, in the same trace color but faded (opacity 0.3). This scatter is computed lazily via a callback and displayed as a temporary Plotly trace that is added on hover and removed on unhover. -- **"No data to plot" annotation**: When no traces match the current filter/settings, the chart displays a Plotly annotation overlay ("No data to plot") centered on the chart area, preserving the x-axis scaffold so the user can see the order range. -- API: `POST query` with JSON body `{machine, metric, test, sort, limit, cursor}` (one fetch pipeline per machine, targeted to discovered tests via multi-value `test`), `GET tests?machine=...&metric=...&name_contains=...` (test name discovery), `GET machines/{name}/runs?sort=order` (x-axis scaffold, per machine), `GET orders` (tags for baseline suggestions), `GET machines` (machine combobox), `GET test-suites/{ts}` (fields/metrics) -- **URL state**: `?suite={ts}&machine={name}&machine={name2}&metric={name}&test_filter={text}&run_agg={fn}&sample_agg={fn}&baseline={suite}::{machine}::{order}&baseline={suite2}::{machine2}::{order2}` — the `machine` parameter is repeated for each selected machine; the `baseline` parameter is repeated for each baseline. Selected tests are NOT included in the URL (names can be very long); they are ephemeral page state preserved across SPA navigation but lost on page reload. +- **Hover** a data point: tooltip showing test name, machine name, commit value, aggregated metric value, run count. Hover distance is reduced (`hoverdistance: 5`, less sticky tooltips) so the tooltip only appears when the cursor is close to a data point. When hovering over an aggregated point that represents multiple runs, the individual pre-aggregation values are shown as a scatter of markers at the same x-position, in the same trace color but faded (opacity 0.3). This scatter is computed lazily via a callback and displayed as a temporary Plotly trace that is added on hover and removed on unhover. +- **"No data to plot" annotation**: When no traces match the current filter/settings, the chart displays a Plotly annotation overlay ("No data to plot") centered on the chart area, preserving the x-axis scaffold so the user can see the commit range. +- API: `POST query` with JSON body `{machine, metric, test, sort, limit, cursor}` (one fetch pipeline per machine, targeted to discovered tests via multi-value `test`), `GET tests?machine=...&metric=...&name_contains=...` (test name discovery), `GET machines/{name}/runs?sort=commit` (x-axis scaffold, per machine), `GET commits` (tags for baseline suggestions), `GET machines` (machine combobox), `GET test-suites/{ts}` (fields/metrics) +- **URL state**: `?suite={ts}&machine={name}&machine={name2}&metric={name}&test_filter={text}&run_agg={fn}&sample_agg={fn}&baseline={suite}::{machine}::{commit}&baseline={suite2}::{machine2}::{commit2}` — the `machine` parameter is repeated for each selected machine; the `baseline` parameter is repeated for each baseline. Selected tests are NOT included in the URL (names can be very long); they are ephemeral page state preserved across SPA navigation but lost on page reload. - **Links out**: Compare ### 7. Compare — `/v5/compare?suite_a={ts}&...` -Side-by-side comparison of two orders (or runs). The existing code in `comparison.ts`, `selection.ts`, `table.ts`, `chart.ts` becomes a page module. The SPA router delegates to it. This page is suite-agnostic — each side can independently select its suite. +Side-by-side comparison of two commits (or runs). The existing code in `comparison.ts`, `selection.ts`, `table.ts`, `chart.ts` becomes a page module. The SPA router delegates to it. This page is suite-agnostic — each side can independently select its suite. #### Selection Panel Each side (A and B) has independent controls: -- **Suite**: dropdown selector populated from `data-testsuites`. Changing the suite clears the machine, order, and runs for that side and re-populates the machine combobox from the new suite's machines endpoint. Clearing the suite also clears cached fields and orders for that side so stale metrics don't linger. -- **Order**: combobox (searchable dropdown) over order values (primary order field only; multi-field orders use only the primary field). Displays tags alongside values (e.g., "abc123 (release-18)") and filters suggestions to only show orders where the selected machine has runs. The text filter matches against both the order value and the tag. When a machine is pre-selected from URL state, its orders are fetched on creation so the dropdown is correctly filtered from the start. **Disabled until a machine is selected** — shows "Select a machine first" placeholder. Re-disabled if the machine is cleared. Clearing the order also clears the runs for that side. -- **Machine**: combobox over machine names. The full machine list for the selected suite is fetched once and filtered locally by case-insensitive substring as the user types (instant, no per-keystroke API calls). **Disabled until a suite is selected** — shows "Select a suite first" placeholder. Clearing the machine text and blurring resets downstream state (order, runs) and disables the order input. -- **Runs**: checkbox list of runs for the selected order+machine, populated by `GET /api/v5/{ts}/runs?machine=M&order=O`. Empty list shown when no runs exist. All runs are selected by default. The only exception is URL state restoration: if the shared URL specifies a subset of runs, that selection is restored. Each run shows its timestamp and a short UUID linking to the Run Detail page. Before an order is selected, a hint message ("Select an order first") is shown instead. +- **Suite**: dropdown selector populated from `data-testsuites`. Changing the suite clears the machine, commit, and runs for that side and re-populates the machine combobox from the new suite's machines endpoint. Clearing the suite also clears cached fields and commits for that side so stale metrics don't linger. +- **Commit**: combobox (searchable dropdown) over commit values (primary commit field only; multi-field commits use only the primary field). Displays tags alongside values (e.g., "abc123 (release-18)") and filters suggestions to only show commits where the selected machine has runs. The text filter matches against both the commit value and the tag. When a machine is pre-selected from URL state, its commits are fetched on creation so the dropdown is correctly filtered from the start. **Disabled until a machine is selected** — shows "Select a machine first" placeholder. Re-disabled if the machine is cleared. Clearing the commit also clears the runs for that side. +- **Machine**: combobox over machine names. The full machine list for the selected suite is fetched once and filtered locally by case-insensitive substring as the user types (instant, no per-keystroke API calls). **Disabled until a suite is selected** — shows "Select a suite first" placeholder. Clearing the machine text and blurring resets downstream state (commit, runs) and disables the commit input. +- **Runs**: checkbox list of runs for the selected commit+machine, populated by `GET /api/v5/{ts}/runs?machine=M&commit=O`. Empty list shown when no runs exist. All runs are selected by default. The only exception is URL state restoration: if the shared URL specifies a subset of runs, that selection is restored. Each run shows its timestamp and a short UUID linking to the Run Detail page. Before a commit is selected, a hint message ("Select a commit first") is shown instead. - **Run aggregation**: strategy for aggregating across selected runs (median/mean/min/max); grayed out when only one run selected -A **Swap sides** button (circular, showing ⇄) sits between the two sides. Clicking it exchanges all of side A's state (order, machine, runs, run aggregation) with side B's, updates the URL, re-renders the selection panel, and triggers auto-compare. This is useful for quickly reversing the baseline/new direction. +A **Swap sides** button (circular, showing ⇄) sits between the two sides. Clicking it exchanges all of side A's state (commit, machine, runs, run aggregation) with side B's, updates the URL, re-renders the selection panel, and triggers auto-compare. This is useful for quickly reversing the baseline/new direction. Global controls (shared across both sides): - **Metric**: single-select dropdown; one metric at a time, applies to both table and chart. Shows the **union** of metrics from both sides' suites. Only metrics with `type === 'Real'` are shown (filtered client-side). Before any suite is selected, the metric area shows a "Select a suite to load metrics..." hint instead of an empty dropdown. @@ -252,7 +252,7 @@ Global controls (shared across both sides): - **Test filter**: text input for substring matching on test names, applied to both table and chart - **Hide noise**: checkbox that hides noise-status rows from the table and chart -There is no Compare button. The comparison triggers automatically whenever the state becomes valid (both sides have runs and a metric is selected), like the Graph page's auto-plot. Changing the machine, order, metric, or aggregation settings re-triggers the comparison. Previous in-flight fetches are aborted. +There is no Compare button. The comparison triggers automatically whenever the state becomes valid (both sides have runs and a metric is selected), like the Graph page's auto-plot. Changing the machine, commit, metric, or aggregation settings re-triggers the comparison. Previous in-flight fetches are aborted. #### Comparison Table @@ -301,21 +301,21 @@ The chart and table always represent the same dataset: #### Data Flow -1. Page loads: fetch metric metadata via `GET test-suites/{ts}` (fields from `schema.metrics`) and all orders via `GET orders` (cursor-paginated) to populate the order comboboxes. -2. User selects order and machine on each side. On each change, fetch `GET runs?machine=M&order=O` to populate the runs checkbox list. If no runs exist, show an empty list. +1. Page loads: fetch metric metadata via `GET test-suites/{ts}` (fields from `schema.metrics`) and all commits via `GET commits` (cursor-paginated) to populate the commit comboboxes. +2. User selects commit and machine on each side. On each change, fetch `GET runs?machine=M&commit=O` to populate the runs checkbox list. If no runs exist, show an empty list. 3. Once both sides have runs and a metric is selected, comparison triggers automatically. Fetch sample data for each selected run via `GET runs/{uuid}/samples` (cursor-paginated with `limit=500`). Show a progress indicator during fetch. 4. Client-side: aggregate samples (within-run via sample aggregation), aggregate across runs (via run aggregation), join on test name, compute derived columns (delta, ratio, status). 5. Render table and chart. 6. Subsequent filter/sort/zoom operations are client-side (data already loaded). 7. If the user changes selections while data is loading, abort the in-flight requests before starting new ones. -**Per-run sample caching**: Fetched samples are cached per run UUID. Changing the metric, aggregation function, noise threshold, or run selection re-aggregates and re-compares from cache without any API calls. Only selecting a new order or machine (which produces different run UUIDs) triggers new fetches, and only for runs not already in the cache. +**Per-run sample caching**: Fetched samples are cached per run UUID. Changing the metric, aggregation function, noise threshold, or run selection re-aggregates and re-compares from cache without any API calls. Only selecting a new commit or machine (which produces different run UUIDs) triggers new fetches, and only for runs not already in the cache. #### URL State All selection state is encoded as query parameters for shareability: -- `suite_a`, `order_a`, `machine_a`, `runs_a` (comma-separated UUIDs), `run_agg_a` -- `suite_b`, `order_b`, `machine_b`, `runs_b`, `run_agg_b` +- `suite_a`, `commit_a`, `machine_a`, `runs_a` (comma-separated UUIDs), `run_agg_a` +- `suite_b`, `commit_b`, `machine_b`, `runs_b`, `run_agg_b` - `metric`, `sample_agg`, `noise` - Filter/sort state as applicable @@ -323,7 +323,7 @@ Auth token is stored in `localStorage`, not in URL state (to avoid leaking crede #### Known Limitations -- Only single-field orders are supported for the order combobox. Multi-field orders use only the primary field. +- Only single-field commits are supported for the commit combobox. Multi-field commits use only the primary field. **Links out**: Machine Detail, Run Detail, Graph (with machine pre-filled). @@ -350,8 +350,8 @@ Not test-suite specific. Served at `/v5/admin` (outside the `{ts}` namespace) wi | Create Suite | Name input + JSON schema definition textarea | `POST test-suites` | **Test Suites tab details**: -- **Suite selector**: Dropdown to switch between test suites. Selecting a suite loads and displays its schema (metrics, order fields, machine fields, run fields). -- **Delete suite**: A delete button per suite. Clicking it shows an inline confirmation panel explaining that deleting a suite permanently destroys all machines, runs, orders, samples, regressions, and field changes, and is irreversible. The user must type the exact suite name to confirm. Calls `DELETE /api/v5/test-suites/{name}?confirm=true`. Requires `manage` scope. +- **Suite selector**: Dropdown to switch between test suites. Selecting a suite loads and displays its schema (metrics, commit fields, machine fields, run fields). +- **Delete suite**: A delete button per suite. Clicking it shows an inline confirmation panel explaining that deleting a suite permanently destroys all machines, runs, commits, samples, regressions, and field changes, and is irreversible. The user must type the exact suite name to confirm. Calls `DELETE /api/v5/test-suites/{name}?confirm=true`. Requires `manage` scope. **Create Suite tab**: - A name input and a JSON textarea where the user pastes the full suite definition (format_version, name, metrics, run_fields, machine_fields). The JSON format matches the `POST /api/v5/test-suites` API. On success, switches to the Schemas tab with the new suite auto-selected. Requires a token with `manage` scope. @@ -391,7 +391,7 @@ lnt/server/ui/v5/frontend/src/ │ ├── test-suites.ts Suite-agnostic test suites page (picker + tabs) │ ├── machine-detail.ts │ ├── run-detail.ts -│ ├── order-detail.ts +│ ├── commit-detail.ts │ ├── graph.ts │ ├── compare.ts Compare page module (auto-compare, caching, row toggling) │ ├── regression-list.ts @@ -405,7 +405,7 @@ lnt/server/ui/v5/frontend/src/ ├── time-series-chart.ts Plotly time-series chart component ├── machine-combobox.ts Standalone machine typeahead selector ├── metric-selector.ts Reusable metric drop-down (supports optional placeholder) - ├── order-search.ts Order search with tag-based autocomplete + ├── commit-search.ts Commit search with tag-based autocomplete └── pagination.ts Cursor/offset pagination controls ``` @@ -415,7 +415,7 @@ lnt/server/ui/v5/frontend/src/ |----------------|----------------| | `api.ts` | Extend with new endpoint functions | | `types.ts` | Extend with new interfaces | -| `combobox.ts` | Reuse for Compare page order/machine selectors (extended with tag display, machine filtering, input validation) | +| `combobox.ts` | Reuse for Compare page commit/machine selectors (extended with tag display, machine filtering, input validation) | | `utils.ts` | Reuse `el()`, `formatValue()`, aggregation functions | | `chart.ts` | Compare page bar chart (extended with text filter, zoom preservation) | | `table.ts` | Compare page table (extended with row toggling, geomean, summary message) | @@ -439,14 +439,14 @@ outDir: resolve(__dirname, '../static/v5'), **None are blocking.** All v4 workflows can be served by the existing v5 API. One optional enhancement for performance: -- `GET /api/v5/{ts}/regressions?include=summary` — enriches list items with `indicator_count`, `earliest_order`, `latest_order` to avoid N+1 fetches on the regression list page. Without this, the frontend can fetch details lazily (regression lists are typically small). +- `GET /api/v5/{ts}/regressions?include=summary` — enriches list items with `indicator_count`, `earliest_commit`, `latest_commit` to avoid N+1 fetches on the regression list page. Without this, the frontend can fetch details lazily (regression lists are typically small). ## Implementation Phases | Phase | Pages | Foundation Work | |-------|-------|-----------------| | 1 | (none visible) | SPA shell, router, nav bar, Flask catch-all route, build config | -| 2 | Test Suites (picker + tabs), Machine Detail, Run Detail, Order Detail | Core browsing — data-table component, pagination, suite picker | +| 2 | Test Suites (picker + tabs), Machine Detail, Run Detail, Commit Detail | Core browsing — data-table component, pagination, suite picker | | 3 | Graph | Time-series chart component, combobox integration, aggregation controls, field change annotations | | 4 | Compare | Absorb existing compare page into SPA as page module, add geomean summary | | 5 | Regression List, Regression Detail, Field Change Triage (stubs) | Stub pages with "Not implemented yet" message | diff --git a/lnt/server/ui/v5/frontend/src/__tests__/api.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/api.test.ts index c77722a29..1c34c32dd 100644 --- a/lnt/server/ui/v5/frontend/src/__tests__/api.test.ts +++ b/lnt/server/ui/v5/frontend/src/__tests__/api.test.ts @@ -938,13 +938,13 @@ describe('fetchOneCursorPage', () => { mockFetch.mockResolvedValueOnce(mockResponse(cursorPage([]))); await fetchOneCursorPage('/api/v5/nts/query', { - machine: 'm1', metric: 'exec_time', sort: '-order', limit: '10000', cursor: 'abc', + machine: 'm1', metric: 'exec_time', sort: '-commit', limit: '10000', cursor: 'abc', }); const url = new URL(mockFetch.mock.calls[0][0]); expect(url.searchParams.get('machine')).toBe('m1'); expect(url.searchParams.get('metric')).toBe('exec_time'); - expect(url.searchParams.get('sort')).toBe('-order'); + expect(url.searchParams.get('sort')).toBe('-commit'); expect(url.searchParams.get('limit')).toBe('10000'); expect(url.searchParams.get('cursor')).toBe('abc'); }); diff --git a/lnt/server/ui/v5/frontend/src/__tests__/pages/admin.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/pages/admin.test.ts index 6632f8efd..40e10b19e 100644 --- a/lnt/server/ui/v5/frontend/src/__tests__/pages/admin.test.ts +++ b/lnt/server/ui/v5/frontend/src/__tests__/pages/admin.test.ts @@ -52,7 +52,7 @@ const mockSuiteInfo: TestSuiteInfo = { metrics: [ { name: 'exec_time', type: 'Real', display_name: 'Execution Time', unit: 's', unit_abbrev: 's', bigger_is_better: false }, ], - order_fields: [{ name: 'rev', type: 'String' }], + commit_fields: [{ name: 'rev', type: 'String' }], machine_fields: [{ name: 'hostname', type: 'String' }], run_fields: [], }, @@ -168,7 +168,7 @@ describe('adminPage', () => { await vi.waitFor(() => { expect(container.textContent).toContain('Metrics'); expect(container.textContent).toContain('Execution Time'); - expect(container.textContent).toContain('Order Fields'); + expect(container.textContent).toContain('Commit Fields'); expect(container.textContent).toContain('rev'); expect(container.textContent).toContain('Machine Fields'); expect(container.textContent).toContain('hostname'); diff --git a/lnt/server/ui/v5/frontend/src/__tests__/pages/graph-data-cache.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/pages/graph-data-cache.test.ts index 47a978332..ef8c57f17 100644 --- a/lnt/server/ui/v5/frontend/src/__tests__/pages/graph-data-cache.test.ts +++ b/lnt/server/ui/v5/frontend/src/__tests__/pages/graph-data-cache.test.ts @@ -3,13 +3,13 @@ import { describe, it, expect, vi, beforeEach } from 'vitest'; import { GraphDataCache, type GraphDataApi } from '../../pages/graph-data-cache'; import type { QueryDataPoint } from '../../types'; -function makePoint(test: string, orderValue: string, value: number, machine = 'm1', metric = 'exec_time'): QueryDataPoint { +function makePoint(test: string, commitValue: string, value: number, machine = 'm1', metric = 'exec_time'): QueryDataPoint { return { test, machine, metric, value, - commit: orderValue, + commit: commitValue, ordinal: null, run_uuid: 'r1', submitted_at: null, diff --git a/lnt/server/ui/v5/frontend/src/__tests__/pages/graph.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/pages/graph.test.ts index a6a6a4745..133bc2aba 100644 --- a/lnt/server/ui/v5/frontend/src/__tests__/pages/graph.test.ts +++ b/lnt/server/ui/v5/frontend/src/__tests__/pages/graph.test.ts @@ -66,13 +66,13 @@ import type { QueryDataPoint, FieldInfo } from '../../types'; // Pure function tests // --------------------------------------------------------------------------- -function makePoint(test: string, orderValue: string, value: number, runUuid = 'r1'): QueryDataPoint { +function makePoint(test: string, commitValue: string, value: number, runUuid = 'r1'): QueryDataPoint { return { test, machine: 'm1', metric: 'exec_time', value, - commit: orderValue, + commit: commitValue, ordinal: null, run_uuid: runUuid, submitted_at: null, @@ -224,8 +224,8 @@ describe('buildTraces', () => { ]; const traces = buildTraces(points, 'median', 'median'); - const orderValues = traces[0].points.map(p => p.commit); - expect(orderValues).toEqual(['100', '101', '102']); + const commitValues = traces[0].points.map(p => p.commit); + expect(commitValues).toEqual(['100', '101', '102']); }); it('preserves insertion order for reversed input (newest-first)', () => { @@ -237,8 +237,8 @@ describe('buildTraces', () => { const traces = buildTraces(points, 'median', 'median'); // buildTraces preserves Map insertion order, so reversed input stays reversed - const orderValues = traces[0].points.map(p => p.commit); - expect(orderValues).toEqual(['102', '101', '100']); + const commitValues = traces[0].points.map(p => p.commit); + expect(commitValues).toEqual(['102', '101', '100']); }); it('handles interleaved test data in reverse order', () => { @@ -262,13 +262,13 @@ describe('buildTraces', () => { }); describe('buildBaselinesFromData', () => { - function makeRefPoint(test: string, orderValue: string, value: number, machine = 'm1'): QueryDataPoint { + function makeRefPoint(test: string, commitValue: string, value: number, machine = 'm1'): QueryDataPoint { return { test, machine, metric: 'exec_time', value, - commit: orderValue, + commit: commitValue, ordinal: null, run_uuid: 'r1', submitted_at: null, diff --git a/lnt/server/ui/v5/frontend/src/__tests__/pages/home.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/pages/home.test.ts index e2813c3ae..3a846393e 100644 --- a/lnt/server/ui/v5/frontend/src/__tests__/pages/home.test.ts +++ b/lnt/server/ui/v5/frontend/src/__tests__/pages/home.test.ts @@ -44,7 +44,7 @@ const mockSuiteInfo: TestSuiteInfo = { { name: 'compile_time', type: 'Real', display_name: 'Compile Time', unit: 'seconds', unit_abbrev: 's', bigger_is_better: false }, ], run_fields: [], - order_fields: [{ name: 'llvm_project_revision', type: 'String' }], + commit_fields: [{ name: 'llvm_project_revision', type: 'String' }], machine_fields: [], }, }; @@ -56,15 +56,15 @@ const mockSuiteInfo2: TestSuiteInfo = { { name: 'score', type: 'Real', display_name: 'Score', unit: null, unit_abbrev: null, bigger_is_better: true }, ], run_fields: [], - order_fields: [{ name: 'revision', type: 'String' }], + commit_fields: [{ name: 'revision', type: 'String' }], machine_fields: [], }, }; const mockRuns: RunInfo[] = [ - { uuid: 'r1', machine: 'machine-a', order: { rev: '100' }, start_time: '2026-01-01T10:00:00Z', end_time: null }, - { uuid: 'r2', machine: 'machine-b', order: { rev: '101' }, start_time: '2026-01-02T10:00:00Z', end_time: null }, - { uuid: 'r3', machine: 'machine-a', order: { rev: '102' }, start_time: '2026-01-03T10:00:00Z', end_time: null }, + { uuid: 'r1', machine: 'machine-a', commit: '100', submitted_at: '2026-01-01T10:00:00Z' }, + { uuid: 'r2', machine: 'machine-b', commit: '101', submitted_at: '2026-01-02T10:00:00Z' }, + { uuid: 'r3', machine: 'machine-a', commit: '102', submitted_at: '2026-01-03T10:00:00Z' }, ]; function mockRunsPage(items: RunInfo[], nextCursor: string | null = null): CursorPageResult { @@ -72,7 +72,7 @@ function mockRunsPage(items: RunInfo[], nextCursor: string | null = null): Curso } const mockTrendsData: TrendsDataPoint[] = [ - { machine: 'machine-a', order: { rev: '100' }, timestamp: '2026-01-01T10:00:00Z', value: 14.14 }, + { machine: 'machine-a', commit: '100', ordinal: null, submitted_at: '2026-01-01T10:00:00Z', value: 14.14 }, ]; let container: HTMLElement; diff --git a/lnt/server/ui/v5/frontend/src/__tests__/time-series-chart.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/time-series-chart.test.ts index de71fab76..57374d5a9 100644 --- a/lnt/server/ui/v5/frontend/src/__tests__/time-series-chart.test.ts +++ b/lnt/server/ui/v5/frontend/src/__tests__/time-series-chart.test.ts @@ -54,7 +54,7 @@ describe('buildPlotlyData', () => { expect(trace.customdata[0][5]).toBe('m1'); // machine }); - it('generates reference order traces with hover', () => { + it('generates reference commit traces with hover', () => { const refValues = new Map(); refValues.set('test-A', 2.5); @@ -487,7 +487,7 @@ describe('createTimeSeriesChart', () => { expect(mockRestyle.mock.calls[0][2]).toEqual([0, 1]); }); - it('hoverTrace() dims reference-order traces along with non-hovered main traces', async () => { + it('hoverTrace() dims reference-commit traces along with non-hovered main traces', async () => { const container = document.createElement('div'); const refValues = new Map(); refValues.set('test-A', 5.0); @@ -531,7 +531,7 @@ describe('createTimeSeriesChart', () => { { testName: 'test-A', machine: 'm1', color: '#1f77b4', points: [{ commit: '100', value: 2.0, runCount: 3, submitted_at: null }] }, ], yAxisLabel: 'metric', - getRawValues: (_test, _machine, _order) => [1.0, 2.0, 3.0], + getRawValues: (_test, _machine, _commit) => [1.0, 2.0, 3.0], }); await new Promise(r => setTimeout(r, 0)); diff --git a/lnt/server/ui/v5/frontend/src/pages/admin.ts b/lnt/server/ui/v5/frontend/src/pages/admin.ts index 11a77ca53..833f645c2 100644 --- a/lnt/server/ui/v5/frontend/src/pages/admin.ts +++ b/lnt/server/ui/v5/frontend/src/pages/admin.ts @@ -324,7 +324,7 @@ function renderCreateSuiteTab( const jsonArea = el('textarea', { class: 'admin-textarea', - placeholder: '{\n "format_version": "2",\n "name": "my_suite",\n "metrics": [\n {"name": "exec_time", "type": "Real", "bigger_is_better": false}\n ],\n "run_fields": [\n {"name": "revision", "order": true}\n ],\n "machine_fields": [\n {"name": "hostname"}\n ]\n}', + placeholder: '{\n "format_version": "5",\n "name": "my_suite",\n "metrics": [\n {"name": "exec_time", "type": "Real", "bigger_is_better": false}\n ],\n "commit_fields": [\n {"name": "revision"}\n ],\n "machine_fields": [\n {"name": "hostname"}\n ]\n}', }) as HTMLTextAreaElement; jsonArea.rows = 10; @@ -348,7 +348,7 @@ function renderCreateSuiteTab( // Ensure name in payload matches the name input payload['name'] = name; - if (!payload['format_version']) payload['format_version'] = '2'; + if (!payload['format_version']) payload['format_version'] = '5'; createBtn.setAttribute('disabled', ''); feedback.replaceChildren(el('span', { class: 'progress-label' }, 'Creating...')); @@ -401,7 +401,7 @@ function renderDeleteSuite( confirmPanel.append(el('p', { class: 'admin-delete-warning' }, `Deleting test suite '${suiteName}' will permanently destroy all machines, runs, ` + - 'orders, samples, regressions, and field changes associated with it. ' + + 'commits, samples, regressions, and field changes associated with it. ' + 'This cannot be undone.', )); @@ -507,7 +507,7 @@ function renderSchemaContent(container: HTMLElement, info: TestSuiteInfo): void // Other schema sections for (const [label, fields] of [ - ['Order Fields', info.schema.order_fields], + ['Commit Fields', info.schema.commit_fields], ['Machine Fields', info.schema.machine_fields], ['Run Fields', info.schema.run_fields], ] as const) { diff --git a/lnt/server/ui/v5/frontend/src/pages/graph.ts b/lnt/server/ui/v5/frontend/src/pages/graph.ts index 75671591b..18a5e3dce 100644 --- a/lnt/server/ui/v5/frontend/src/pages/graph.ts +++ b/lnt/server/ui/v5/frontend/src/pages/graph.ts @@ -332,14 +332,14 @@ export const graphPage: PageModule = { baselineCommitCache.set(suite, []); } })(); - const machineOrdersPromise = fetchMachineCommitSet(suite, name) + const machineCommitsPromise = fetchMachineCommitSet(suite, name) .catch(() => null as Set | null); await commitListPromise; - // Create order picker with machine-commit filtering + // Create commit picker with machine-commit filtering const picker = createCommitPicker({ - id: 'baseline-order', + id: 'baseline-commit', getCommitData: () => { const values = baselineCommitCache.get(suite); return { values: values ?? [] }; @@ -354,9 +354,9 @@ export const graphPage: PageModule = { blCommitContainer.append(picker.element); blCommitCleanup = picker.destroy; - // Apply machine orders once ready (may already be resolved) - const machineOrders = await machineOrdersPromise; - blMachineCommits = machineOrders; + // Apply machine commits once ready (may already be resolved) + const machineCommits = await machineCommitsPromise; + blMachineCommits = machineCommits; }, onClear: () => { blSelectedMachine = ''; @@ -955,7 +955,7 @@ export function buildTraces( */ export function buildBaselinesFromData( baselines: Array<{ suite: string; machine: string; commit: string }>, - getPoints: (suite: string, machine: string, order: string, metric: string) => QueryDataPoint[], + getPoints: (suite: string, machine: string, commit: string, metric: string) => QueryDataPoint[], metric: string, aggFn: (values: number[]) => number, ): PinnedBaseline[] { diff --git a/lnt/server/ui/v5/frontend/src/pages/home.ts b/lnt/server/ui/v5/frontend/src/pages/home.ts index 0fdc6cc41..c049567ed 100644 --- a/lnt/server/ui/v5/frontend/src/pages/home.ts +++ b/lnt/server/ui/v5/frontend/src/pages/home.ts @@ -34,7 +34,7 @@ function isValidRange(s: string): s is RangePreset { /** * Fetch trend data for one metric across multiple machines. - * Returns sparkline traces with server-computed geomean values per order. + * Returns sparkline traces with server-computed geomean values per commit. */ async function fetchSuiteTrends( suite: string, diff --git a/lnt/server/ui/v5/frontend/src/selection.ts b/lnt/server/ui/v5/frontend/src/selection.ts index 2c1bf9a66..69cbb40d0 100644 --- a/lnt/server/ui/v5/frontend/src/selection.ts +++ b/lnt/server/ui/v5/frontend/src/selection.ts @@ -215,7 +215,7 @@ function createSampleAggSelect(): HTMLSelectElement { } /** - * Fetch orders and fields for a side when its suite changes. + * Fetch commits and fields for a side when its suite changes. * Updates the per-side cache and re-renders metric selector. */ export async function fetchSideData( @@ -307,7 +307,7 @@ export function renderSelectionPanel(root: HTMLElement): void { if (newSuite) { fetchSideData(side, newSuite); } else { - // Clear cached data for this side so metrics/orders don't linger + // Clear cached data for this side so metrics/commits don't linger if (side === 'a') { cachedFieldsA = []; cachedCommitsA = []; } else { cachedFieldsB = []; cachedCommitsB = []; } } @@ -327,7 +327,7 @@ export function renderSelectionPanel(root: HTMLElement): void { sideDiv.append(createMachineCombobox(side, setSide, refreshRuns, ctx)); // Order - sideDiv.append(el('label', {}, 'Order')); + sideDiv.append(el('label', {}, 'Commit')); sideDiv.append(createCommitCombobox(side, setSide, refreshRuns, ctx)); // Runs diff --git a/lnt/server/ui/v5/frontend/src/style.css b/lnt/server/ui/v5/frontend/src/style.css index 0579edf44..ec01638df 100644 --- a/lnt/server/ui/v5/frontend/src/style.css +++ b/lnt/server/ui/v5/frontend/src/style.css @@ -863,12 +863,12 @@ dl { box-shadow: 0 0 0 2px rgba(214, 39, 40, 0.15) !important; } -/* Order detail */ -.order-fields { +/* Commit detail */ +.commit-fields { margin-bottom: 10px; } -.order-nav { +.commit-nav { display: flex; gap: 10px; margin: 10px 0; diff --git a/tests/server/ui/v5/test_spa_shell.py b/tests/server/ui/v5/test_spa_shell.py index f1231c387..69d8dab68 100644 --- a/tests/server/ui/v5/test_spa_shell.py +++ b/tests/server/ui/v5/test_spa_shell.py @@ -51,8 +51,8 @@ def test_runs_route(self): html = resp.get_data(as_text=True) self.assertIn('id="v5-app"', html) - def test_orders_route(self): - resp = self.client.get('/v5/nts/orders/some-value') + def test_commits_route(self): + resp = self.client.get('/v5/nts/commits/some-value') self.assertEqual(resp.status_code, 200) html = resp.get_data(as_text=True) self.assertIn('id="v5-app"', html) From de33831ff5c0825fed3f91e30cacc75376be2f9e Mon Sep 17 00:00:00 2001 From: Louis Dionne Date: Tue, 14 Apr 2026 20:32:45 -0400 Subject: [PATCH 060/143] =?UTF-8?q?[UI]=20Fix=20Dashboard=20runtime=20bugs?= =?UTF-8?q?=20from=20Order=E2=86=92Commit=20rebase?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Fix item.timestamp → item.submitted_at in trend data processing (TrendsDataPoint field was renamed but home.ts was not updated, causing all sparkline data to be silently dropped). Fix sort param from -start_time to -submitted_at. Add regression test verifying trend data flows through to Plotly charts. Co-Authored-By: Claude Opus 4.6 (1M context) --- .../v5/frontend/src/__tests__/pages/home.test.ts | 15 +++++++++++++++ lnt/server/ui/v5/frontend/src/pages/home.ts | 6 +++--- 2 files changed, 18 insertions(+), 3 deletions(-) diff --git a/lnt/server/ui/v5/frontend/src/__tests__/pages/home.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/pages/home.test.ts index 3a846393e..ccea624d4 100644 --- a/lnt/server/ui/v5/frontend/src/__tests__/pages/home.test.ts +++ b/lnt/server/ui/v5/frontend/src/__tests__/pages/home.test.ts @@ -81,6 +81,7 @@ let savedReplaceState: typeof window.history.replaceState; beforeEach(() => { vi.clearAllMocks(); container = document.createElement('div'); + document.body.append(container); // Mock window.history.replaceState savedReplaceState = window.history.replaceState; @@ -97,6 +98,7 @@ beforeEach(() => { afterEach(() => { if (homePage.unmount) homePage.unmount(); + container.remove(); window.history.replaceState = savedReplaceState; }); @@ -153,4 +155,17 @@ describe('Dashboard page', () => { expect(getRunsPage).toHaveBeenCalledTimes(2); }, { timeout: 500 }); }); + + it('passes trend data through to Plotly sparkline charts', async () => { + homePage.mount(container, { testsuite: '' }); + + await vi.waitFor(() => { + const calls = ((globalThis as Record).Plotly as Record>).newPlot.mock.calls; + // Find a call with non-empty trace data (not a loading placeholder) + const dataCall = calls.find( + (c: unknown[]) => Array.isArray(c[1]) && c[1].length > 0 && c[1][0].x?.length > 0, + ); + expect(dataCall).toBeTruthy(); + }, { timeout: 500 }); + }); }); diff --git a/lnt/server/ui/v5/frontend/src/pages/home.ts b/lnt/server/ui/v5/frontend/src/pages/home.ts index c049567ed..b73dc34f0 100644 --- a/lnt/server/ui/v5/frontend/src/pages/home.ts +++ b/lnt/server/ui/v5/frontend/src/pages/home.ts @@ -48,10 +48,10 @@ async function fetchSuiteTrends( // Group API response by machine, build SparklineTrace per machine const byMachine = new Map>(); for (const item of items) { - if (!item.timestamp) continue; + if (!item.submitted_at) continue; let points = byMachine.get(item.machine); if (!points) { points = []; byMachine.set(item.machine, points); } - points.push({ timestamp: item.timestamp, value: item.value }); + points.push({ timestamp: item.submitted_at, value: item.value }); } const traces: SparklineTrace[] = []; @@ -168,7 +168,7 @@ export const homePage: PageModule = { // Fetch suite info and recent runs in parallel const [suiteInfo, runsPage] = await Promise.all([ getTestSuiteInfo(suite, sig), - getRunsPage(suite, { sort: '-start_time', limit: 50 }, sig), + getRunsPage(suite, { sort: '-submitted_at', limit: 50 }, sig), ]); if (sig.aborted) return; From f5d41c1020c400bad9b3f790b11cf379b1abf8ad Mon Sep 17 00:00:00 2001 From: Louis Dionne Date: Wed, 15 Apr 2026 09:20:39 -0400 Subject: [PATCH 061/143] [Docker] Fix v5 deployment bugs and add end-to-end smoke test The v5 Docker deployment was broken by two issues: the SPA template referenced v4 blueprint routes (url_for('lnt.static')) that don't exist in v5-only mode, and the v5 API middleware assumed V5DB without checking. Fix the template to use v5 blueprint static assets and pass lnt_url_base and v4_url as template variables. Add an isinstance(db, V5DB) guard in the middleware that returns a clear 500 error instead of AttributeError. Add tests/docker/smoke-test.sh that builds the Docker Compose stack from source, creates a test suite via the API, and exercises 17 endpoint checks across SPA shell, discovery, suite CRUD, run submission, reads, and query. Uses an isolated project name and port to avoid interfering with local dev. Also clean up compose.yaml: remove hardcoded container_name directives (enables parallel stacks), make host port and worker count configurable via LNT_HOST_PORT and GUNICORN_WORKERS environment variables, and fix DB_HOST to use the service name 'db' instead of the old container name. Co-Authored-By: Claude Opus 4.6 (1M context) --- .github/workflows/build-docker.yaml | 21 +- .gitignore | 1 + deployment/README.md | 4 +- docker/compose.yaml | 10 +- docker/docker-entrypoint.sh | 21 +- lnt/server/api/v5/middleware.py | 31 ++- lnt/server/ui/v5/frontend/public/favicon.ico | Bin 0 -> 1406 bytes lnt/server/ui/v5/templates/v5_app.html | 6 +- lnt/server/ui/v5/views.py | 13 +- pyproject.toml | 7 + tests/docker/smoke-test.sh | 213 +++++++++++++++++++ 11 files changed, 280 insertions(+), 47 deletions(-) create mode 100644 lnt/server/ui/v5/frontend/public/favicon.ico create mode 100755 tests/docker/smoke-test.sh diff --git a/.github/workflows/build-docker.yaml b/.github/workflows/build-docker.yaml index a846fae05..c2dd40bb2 100644 --- a/.github/workflows/build-docker.yaml +++ b/.github/workflows/build-docker.yaml @@ -38,19 +38,8 @@ jobs: # Use the current directory as context, as checked out by actions/checkout -- needed for setuptools_scm context: . - - name: Smoke test - start server and ping it - run: | - docker compose -f docker/compose.yaml up --build --detach - timeout 120 bash -c 'until curl -sf http://localhost:8000; do sleep 2; done' - curl -f http://localhost:8000 - env: - LNT_DB_PASSWORD: smoke-test-password - LNT_AUTH_TOKEN: smoke-test-token - - - name: Dump logs on failure - if: failure() - run: docker compose -f docker/compose.yaml logs - - - name: Teardown - if: always() - run: docker compose -f docker/compose.yaml down + - name: Install tox + run: pip install tox + + - name: Smoke test - v5 Docker deployment + run: tox -e docker diff --git a/.gitignore b/.gitignore index a56b24a79..b48532a8b 100644 --- a/.gitignore +++ b/.gitignore @@ -14,3 +14,4 @@ lnt/server/ui/v5/frontend/node_modules/ lnt/server/ui/v5/static/v5/v5.js lnt/server/ui/v5/static/v5/v5.js.map lnt/server/ui/v5/static/v5/v5.css +lnt/server/ui/v5/static/v5/favicon.ico diff --git a/deployment/README.md b/deployment/README.md index aa62f2cdf..3b9ef9a7f 100644 --- a/deployment/README.md +++ b/deployment/README.md @@ -44,8 +44,8 @@ The Docker Compose service itself should now be running, and it can be inspected ```bash docker ps -docker logs webserver -docker logs dbserver # usually less interesting +docker compose -f docker/compose.yaml logs webserver +docker compose -f docker/compose.yaml logs db # usually less interesting ``` The database is stored in an independent EBS storage that gets attached and detached diff --git a/docker/compose.yaml b/docker/compose.yaml index 0c999650f..73d1c1b1a 100644 --- a/docker/compose.yaml +++ b/docker/compose.yaml @@ -21,6 +21,9 @@ # # Additionally, the following aspects can be customized: # +# LNT_HOST_PORT +# The host port to expose the webserver on. Defaults to '8000'. +# # LNT_NGINX_CONFIG # The path to the configuration file to use for Nginx. By default, './nginx.conf' # is used, however this must be specified whenever running from a host where the @@ -35,16 +38,16 @@ name: llvm-lnt services: webserver: - container_name: webserver build: context: ../ dockerfile: docker/lnt.dockerfile environment: - DB_USER=lntuser - - DB_HOST=dbserver + - DB_HOST=db - DB_NAME=lnt - DB_PASSWORD_FILE=/run/secrets/lnt-db-password - AUTH_TOKEN_FILE=/run/secrets/lnt-auth-token + - GUNICORN_WORKERS=${GUNICORN_WORKERS:-8} secrets: - lnt-db-password - lnt-auth-token @@ -56,12 +59,11 @@ services: volumes: - instance:/var/lib/lnt ports: - - "8000:8000" + - "${LNT_HOST_PORT:-8000}:8000" networks: - lnt_network db: - container_name: dbserver image: docker.io/postgres:18-alpine environment: - POSTGRES_PASSWORD_FILE=/run/secrets/lnt-db-password diff --git a/docker/docker-entrypoint.sh b/docker/docker-entrypoint.sh index 226084f5f..014379aa8 100755 --- a/docker/docker-entrypoint.sh +++ b/docker/docker-entrypoint.sh @@ -6,22 +6,25 @@ password="$(cat ${DB_PASSWORD_FILE})" token="$(cat ${AUTH_TOKEN_FILE})" DB_PATH="postgres://${DB_USER}:${password}@${DB_HOST}" +INSTANCE_DIR=/var/lib/lnt/instance + # Set up the instance the first time this gets run. -if [ ! -e /var/lib/lnt/instance/lnt.cfg ]; then +if [ ! -e "${INSTANCE_DIR}/lnt.cfg" ]; then lnt-wait-db "${DB_PATH}/${DB_NAME}" - lnt create /var/lib/lnt/instance \ - --wsgi lnt_wsgi.py \ - --tmp-dir /tmp/lnt \ - --db-dir "${DB_PATH}" \ - --default-db "${DB_NAME}" \ - --api-auth-token "${token}" + lnt create "${INSTANCE_DIR}" \ + --wsgi lnt_wsgi.py \ + --tmp-dir /tmp/lnt \ + --db-dir "${DB_PATH}" \ + --default-db "${DB_NAME}" \ + --api-auth-token "${token}" \ + --db-version 5.0 fi # Run the server under gunicorn. -cd /var/lib/lnt/instance +cd "${INSTANCE_DIR}" exec gunicorn lnt_wsgi:application \ --bind 0.0.0.0:8000 \ - --workers 8 \ + --workers "${GUNICORN_WORKERS:-8}" \ --timeout 300 \ --name lnt_server \ --access-logfile - \ diff --git a/lnt/server/api/v5/middleware.py b/lnt/server/api/v5/middleware.py index 7075282b9..5dd4f586a 100644 --- a/lnt/server/api/v5/middleware.py +++ b/lnt/server/api/v5/middleware.py @@ -5,7 +5,10 @@ import logging import sys -from flask import current_app, g, jsonify, request +from flask import current_app, g, request + +from lnt.server.db.v5 import V5DB +from lnt.server.api.v5.errors import _make_error_response access_logger = logging.getLogger('lnt.server.api.v5.access') @@ -35,7 +38,18 @@ def v5_before_request(): # Always open a DB session for v5 paths (needed for auth, discovery, etc.) db = current_app.instance.get_database("default") if db is None: - return + return _make_error_response( + 'configuration_error', + "No default database configured.", + 500, + ) + if not isinstance(db, V5DB): + return _make_error_response( + 'configuration_error', + "The v5 API requires a v5 database " + "(set db_version to '5.0' in lnt.cfg).", + 500, + ) g.db = db g.db_name = "default" g.db_session = db.make_session() @@ -49,14 +63,11 @@ def v5_before_request(): if testsuite: ts = db.get_suite(testsuite, g.db_session) if ts is None: - resp = jsonify({ - 'error': { - 'code': 'not_found', - 'message': "Test suite '%s' not found" % testsuite, - } - }) - resp.status_code = 404 - return resp + return _make_error_response( + 'not_found', + "Test suite '%s' not found" % testsuite, + 404, + ) g.ts = ts @app.teardown_request diff --git a/lnt/server/ui/v5/frontend/public/favicon.ico b/lnt/server/ui/v5/frontend/public/favicon.ico new file mode 100644 index 0000000000000000000000000000000000000000..739611789fd02e076331233b22faf2bb6888459d GIT binary patch literal 1406 zcmeHDF%E!02rDEejyE|w`ZWJ{55xk=1y?5rAV4X-8wv<>3`E=;a1dQAr%sk&XAh9G rU^C-pnA2xRJJ1fa1796bdA(F&7KT@qV1mz^Ga+2k)U369@IUwfB}NCH literal 0 HcmV?d00001 diff --git a/lnt/server/ui/v5/templates/v5_app.html b/lnt/server/ui/v5/templates/v5_app.html index 8eb201518..ff3d58611 100644 --- a/lnt/server/ui/v5/templates/v5_app.html +++ b/lnt/server/ui/v5/templates/v5_app.html @@ -4,8 +4,8 @@ {{ old_config.name }}{% if g.testsuite_name %} : {{ g.testsuite_name }}{% endif %} - v5 UI - - + + @@ -13,7 +13,7 @@
    + data-v4-url="{{ v4_url }}">
    diff --git a/lnt/server/ui/v5/views.py b/lnt/server/ui/v5/views.py index 8cfea3811..238ffef13 100644 --- a/lnt/server/ui/v5/views.py +++ b/lnt/server/ui/v5/views.py @@ -5,6 +5,14 @@ from lnt.server.ui.decorators import _make_db_session +def _v5_render(**kwargs): + """Render the v5 SPA shell with common template variables.""" + return render_template("v5_app.html", + lnt_url_base='', + v4_url='', + **kwargs) + + @v5_frontend.route("/v5/", strict_slashes=False) @v5_frontend.route("/v5/test-suites", strict_slashes=False) @v5_frontend.route("/v5/admin", strict_slashes=False) @@ -21,8 +29,7 @@ def v5_global(): _make_db_session(None) try: db = request.get_db() - return render_template("v5_app.html", - testsuites=sorted(db.testsuite.keys())) + return _v5_render(testsuites=sorted(db.testsuite.keys())) finally: request.session.close() @@ -42,6 +49,6 @@ def v5_app(testsuite_name, subpath=None): data = ts_data(ts) db = request.get_db() data['testsuites'] = sorted(db.testsuite.keys()) - return render_template("v5_app.html", **data) + return _v5_render(**data) finally: request.session.close() diff --git a/pyproject.toml b/pyproject.toml index 52e261a1d..027f402d4 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -104,6 +104,7 @@ find = {namespaces = false} "static/v5/*.js", "static/v5/*.css", "static/v5/*.map", + "static/v5/*.ico", ] "lnt.server.db" = [ "migrations/*.py" @@ -160,6 +161,12 @@ deps = [ commands = [["mypy", "--ignore-missing-imports", "lnt"]] skip_install = true +[tool.tox.env.docker] +description = "Run Docker integration tests (requires Docker)" +allowlist_externals = ["tests/docker/smoke-test.sh"] +commands = [["tests/docker/smoke-test.sh"]] +skip_install = true + [tool.tox.env.docs] description = "Build the documentation" deps = [ diff --git a/tests/docker/smoke-test.sh b/tests/docker/smoke-test.sh new file mode 100755 index 000000000..b95b1bca8 --- /dev/null +++ b/tests/docker/smoke-test.sh @@ -0,0 +1,213 @@ +#!/usr/bin/env bash +# End-to-end smoke test for the Docker-based LNT deployment. +# +# Builds the Docker Compose stack from the currently checked-out source, +# creates a test suite via the API, exercises all key v5 endpoints, and +# tears down with volume removal on exit. +# +# Uses a separate compose project name and host port to avoid interfering +# with any local development stack. +# +# Usage: +# ./tests/docker/smoke-test.sh +# +# Requirements: docker, docker compose, curl, jq + +set -euo pipefail + +REPO_ROOT="$(cd "$(dirname "$0")/../.." && pwd)" +COMPOSE_FILE="${REPO_ROOT}/docker/compose.yaml" +PROJECT_NAME="lnt-smoke-test-$$" +HOST_PORT=$(python3 -c "import socket; s=socket.socket(); s.bind(('',0)); print(s.getsockname()[1]); s.close()") +BASE_URL="http://localhost:${HOST_PORT}" +AUTH_TOKEN="smoke-test-token" +SUITE="smoketest" + +# Export secrets and port override for docker compose. +export LNT_DB_PASSWORD="smoke-test-password" +export LNT_AUTH_TOKEN="${AUTH_TOKEN}" +export LNT_HOST_PORT="${HOST_PORT}" +# Use 1 worker to avoid multi-worker schema cache reload issues +# (the test creates a suite at runtime; other workers wouldn't see it). +export GUNICORN_WORKERS=1 + +# Common compose flags: use isolated project name. +COMPOSE_CMD=(docker compose -f "$COMPOSE_FILE" -p "$PROJECT_NAME") + +# --------------------------------------------------------------------------- +# Helpers +# --------------------------------------------------------------------------- +pass_count=0 +fail_count=0 + +pass() { echo " PASS $1"; pass_count=$((pass_count + 1)); } +fail() { echo " FAIL $1 -- $2"; fail_count=$((fail_count + 1)); } + +# check_endpoint LABEL URL EXPECTED_STATUS [METHOD [BODY [JQ_EXPR]]] +# +# Single curl call that checks the HTTP status code and optionally validates +# a jq expression on the response body. +check_endpoint() { + local label="$1" url="$2" expected="$3" method="${4:-GET}" body="${5:-}" jq_expr="${6:-}" + local args=(-s -w '\n%{http_code}' -L -X "$method") + if [ -n "$body" ]; then + args+=(-H 'Content-Type: application/json' -d "$body") + fi + args+=(-H "Authorization: Bearer ${AUTH_TOKEN}") + + local output status json_body + output=$(curl "${args[@]}" "$url") + status="${output##*$'\n'}" + json_body="${output%$'\n'*}" + + if [ "$status" = "$expected" ]; then + pass "$label (HTTP $status)" + else + fail "$label" "expected $expected, got $status" + return + fi + + if [ -n "$jq_expr" ]; then + local result + result=$(echo "$json_body" | jq -r "$jq_expr" 2>/dev/null) + if [ -n "$result" ] && [ "$result" != "null" ]; then + pass "$label: $jq_expr = $result" + else + fail "$label: $jq_expr" "returned empty/null" + fi + fi +} + +cleanup() { + echo "" + echo "Tearing down smoke-test Docker stack..." + "${COMPOSE_CMD[@]}" down -v --remove-orphans 2>/dev/null || true + docker rmi "${PROJECT_NAME}-webserver" 2>/dev/null || true +} +trap cleanup EXIT + +# --------------------------------------------------------------------------- +# Start +# --------------------------------------------------------------------------- +echo "=== LNT Docker Smoke Test ===" +echo " project: ${PROJECT_NAME}" +echo " port: ${HOST_PORT}" +echo "" + +echo "Building and starting Docker Compose stack..." +"${COMPOSE_CMD[@]}" up --build --detach + +# Wait for the container's webserver to be listening, using the API discovery +# endpoint (simpler than the SPA route which depends on templates). +echo "Waiting for server to be ready..." +timeout 120 bash -c " + until curl -sf http://localhost:${HOST_PORT}/api/v5/ > /dev/null 2>&1; do + sleep 2 + done +" || { + echo "Server did not become ready in 120s. Logs:" + "${COMPOSE_CMD[@]}" logs + exit 1 +} +echo "Server is ready." +echo "" + +# --------------------------------------------------------------------------- +# Test: SPA shell +# --------------------------------------------------------------------------- +echo "--- SPA Shell ---" +check_endpoint "GET /v5/" "${BASE_URL}/v5/" 200 + +# --------------------------------------------------------------------------- +# Test: Discovery +# --------------------------------------------------------------------------- +echo "--- Discovery ---" +check_endpoint "GET /api/v5/" "${BASE_URL}/api/v5/" 200 GET "" ".test_suites | type" + +# --------------------------------------------------------------------------- +# Test: Create test suite +# --------------------------------------------------------------------------- +echo "--- Test Suite CRUD ---" +SUITE_BODY=$(cat <<'ENDJSON' +{ + "name": "smoketest", + "metrics": [ + {"name": "execution_time", "type": "real", "unit": "seconds"}, + {"name": "compile_time", "type": "real", "unit": "seconds"} + ], + "commit_fields": [ + {"name": "git_sha", "searchable": true} + ], + "machine_fields": [ + {"name": "os", "searchable": true} + ] +} +ENDJSON +) +check_endpoint "POST /api/v5/test-suites (create)" \ + "${BASE_URL}/api/v5/test-suites" 201 POST "$SUITE_BODY" + +check_endpoint "GET /api/v5/test-suites/${SUITE}" \ + "${BASE_URL}/api/v5/test-suites/${SUITE}" 200 GET "" ".schema.name" + +# --------------------------------------------------------------------------- +# Test: Submit a run +# --------------------------------------------------------------------------- +echo "--- Run Submission ---" +RUN_BODY=$(cat <<'ENDJSON' +{ + "format_version": "5", + "machine": {"name": "smoke-machine", "os": "linux"}, + "commit": "abc123", + "commit_fields": {"git_sha": "abc123def456"}, + "tests": [ + {"name": "test.suite/bench1", "execution_time": 1.5, "compile_time": 0.3}, + {"name": "test.suite/bench2", "execution_time": 2.0, "compile_time": 0.5} + ] +} +ENDJSON +) +check_endpoint "POST /api/v5/${SUITE}/runs (submit)" \ + "${BASE_URL}/api/v5/${SUITE}/runs" 201 POST "$RUN_BODY" + +# --------------------------------------------------------------------------- +# Test: Read endpoints +# --------------------------------------------------------------------------- +echo "--- Read Endpoints ---" +check_endpoint "GET /api/v5/${SUITE}/runs" \ + "${BASE_URL}/api/v5/${SUITE}/runs" 200 GET "" ".items | length" + +check_endpoint "GET /api/v5/${SUITE}/machines" \ + "${BASE_URL}/api/v5/${SUITE}/machines" 200 GET "" ".items | length" + +check_endpoint "GET /api/v5/${SUITE}/commits" \ + "${BASE_URL}/api/v5/${SUITE}/commits" 200 GET "" ".items | length" + +check_endpoint "GET /api/v5/${SUITE}/tests" \ + "${BASE_URL}/api/v5/${SUITE}/tests" 200 GET "" ".items | length" + +# --------------------------------------------------------------------------- +# Test: Time-series query +# --------------------------------------------------------------------------- +echo "--- Time-Series Query ---" +QUERY_BODY=$(cat <<'ENDJSON' +{ + "metric": "execution_time", + "machine": "smoke-machine" +} +ENDJSON +) +check_endpoint "POST /api/v5/${SUITE}/query" \ + "${BASE_URL}/api/v5/${SUITE}/query" 200 POST "$QUERY_BODY" ".items | length" + +# --------------------------------------------------------------------------- +# Summary +# --------------------------------------------------------------------------- +echo "" +echo "=== Results: ${pass_count} passed, ${fail_count} failed ===" +if [ "$fail_count" -gt 0 ]; then + echo "" + echo "Docker logs:" + "${COMPOSE_CMD[@]}" logs --tail=50 + exit 1 +fi From cce04709054ac824eaaec8d8e4c05bec941187b6 Mon Sep 17 00:00:00 2001 From: Louis Dionne Date: Wed, 15 Apr 2026 10:35:24 -0400 Subject: [PATCH 062/143] [DB] Fix multi-worker schema staleness: check freshness on every API request Each Gunicorn worker caches a single V5DB instance for its lifetime. When one worker creates or deletes a test suite, other workers' caches become stale. The existing staleness check only ran inside get_suite(), which was only called for per-suite URL routes -- discovery, list, and test-suite management endpoints never triggered it. Add V5DB.ensure_fresh(session) and call it in middleware on every /api/v5/ request. Simplify get_suite() to a plain dict lookup. Remove the GUNICORN_WORKERS override plumbing from Docker (compose.yaml, entrypoint, smoke test) since it was only needed as a workaround. Co-Authored-By: Claude Opus 4.6 (1M context) --- docker/compose.yaml | 1 - docker/docker-entrypoint.sh | 2 +- docs/design/v5-db.md | 8 ++++---- docs/v5-db-implementation-plan.md | 10 ++++------ lnt/server/api/v5/middleware.py | 11 +++++++---- lnt/server/db/v5/__init__.py | 24 ++++++++++++------------ tests/docker/smoke-test.sh | 3 --- tests/server/api/v5/test_test_suites.py | 15 ++++----------- tests/server/db/v5/test_import.py | 5 ++++- 9 files changed, 36 insertions(+), 43 deletions(-) diff --git a/docker/compose.yaml b/docker/compose.yaml index 73d1c1b1a..bf046ac27 100644 --- a/docker/compose.yaml +++ b/docker/compose.yaml @@ -47,7 +47,6 @@ services: - DB_NAME=lnt - DB_PASSWORD_FILE=/run/secrets/lnt-db-password - AUTH_TOKEN_FILE=/run/secrets/lnt-auth-token - - GUNICORN_WORKERS=${GUNICORN_WORKERS:-8} secrets: - lnt-db-password - lnt-auth-token diff --git a/docker/docker-entrypoint.sh b/docker/docker-entrypoint.sh index 014379aa8..059387f6b 100755 --- a/docker/docker-entrypoint.sh +++ b/docker/docker-entrypoint.sh @@ -24,7 +24,7 @@ fi cd "${INSTANCE_DIR}" exec gunicorn lnt_wsgi:application \ --bind 0.0.0.0:8000 \ - --workers "${GUNICORN_WORKERS:-8}" \ + --workers 8 \ --timeout 300 \ --name lnt_server \ --access-logfile - \ diff --git a/docs/design/v5-db.md b/docs/design/v5-db.md index 359c4b038..2fd19dd75 100644 --- a/docs/design/v5-db.md +++ b/docs/design/v5-db.md @@ -70,10 +70,10 @@ is cached. **Multi-process safety**: In a multi-worker deployment (e.g., gunicorn), when one worker creates or deletes a suite, it bumps the `v5_schema_version` counter -in the same transaction. Other workers detect the stale cache on their next -request and reload schemas from the DB. The check is a single-row query per -request. Callers access suites via `V5DB.get_suite(name)`, which handles the -staleness check transparently. +in the same transaction. The v5 API middleware calls `V5DB.ensure_fresh()` at +the start of every request, which compares the cached version against the DB +and reloads all schemas when they differ. The check is a single-row integer +read per request. ## D4: Schema Format diff --git a/docs/v5-db-implementation-plan.md b/docs/v5-db-implementation-plan.md index ef2973bcc..0ab13907c 100644 --- a/docs/v5-db-implementation-plan.md +++ b/docs/v5-db-implementation-plan.md @@ -112,12 +112,10 @@ import from their schema modules. Do each endpoint+schema pair together. ### 2.1 Middleware (`middleware.py`) Replace testsuite resolution: -- Remove `db.check_registry_version(g.db_session)` call (v4 method). - `V5DB.get_suite()` handles staleness checks internally. -- Replace the `if testsuite not in db.testsuite` check + `g.ts = - db.testsuite[testsuite]` with a single call: `g.ts = - db.get_suite(testsuite, g.db_session)`. Return 404 if `None`. This avoids - a TOCTOU race between the `in` check and the dict lookup. +- Call `db.ensure_fresh(g.db_session)` on every `/api/v5/` request to detect + schema changes made by other workers. +- Resolve the testsuite (if any) with `g.ts = db.get_suite(testsuite)`. + Return 404 if `None`. - `g.db` is now always a `V5DB`. No dual-path code. - `v5_teardown_request()` unchanged (session commit/rollback/close). diff --git a/lnt/server/api/v5/middleware.py b/lnt/server/api/v5/middleware.py index 5dd4f586a..a4dc10dc7 100644 --- a/lnt/server/api/v5/middleware.py +++ b/lnt/server/api/v5/middleware.py @@ -54,14 +54,17 @@ def v5_before_request(): g.db_name = "default" g.db_session = db.make_session() + # Ensure the in-memory schema cache is up-to-date. In a + # multi-worker deployment another worker may have created or + # deleted a test suite; this single-row integer check detects + # that and reloads the cache before any endpoint runs. + db.ensure_fresh(g.db_session) + # Resolve testsuite from view_args if the URL contains one. - # Discovery (/api/v5/) and admin (/api/v5/admin/) paths have no - # testsuite in the URL. get_suite() handles schema version - # staleness checks transparently. view_args = request.view_args or {} testsuite = view_args.get('testsuite') if testsuite: - ts = db.get_suite(testsuite, g.db_session) + ts = db.get_suite(testsuite) if ts is None: return _make_error_response( 'not_found', diff --git a/lnt/server/db/v5/__init__.py b/lnt/server/db/v5/__init__.py index d44097b8e..53d0c80e5 100644 --- a/lnt/server/db/v5/__init__.py +++ b/lnt/server/db/v5/__init__.py @@ -183,18 +183,18 @@ def _bump_schema_version(session: sqlalchemy.orm.Session) -> None: else: row.version = row.version + 1 - def get_suite(self, name: str, session: sqlalchemy.orm.Session | None = None) -> V5TestSuiteDB | None: - """Return a suite by name, transparently reloading if stale.""" - if session is not None: - if self._check_schema_version(session): - self._load_schemas_from_db() - else: - session = self.sessionmaker() - try: - if self._check_schema_version(session): - self._load_schemas_from_db() - finally: - session.close() + def ensure_fresh(self, session: sqlalchemy.orm.Session) -> None: + """Reload schemas from the DB if the cached version is stale. + + Call this once per request (e.g. in middleware) so that all + endpoints see up-to-date test-suite definitions, even when + another worker created or deleted a suite. + """ + if self._check_schema_version(session): + self._load_schemas_from_db() + + def get_suite(self, name: str) -> V5TestSuiteDB | None: + """Return a suite by name, or None.""" return self.testsuite.get(name) def create_suite( diff --git a/tests/docker/smoke-test.sh b/tests/docker/smoke-test.sh index b95b1bca8..8cf0d1e71 100755 --- a/tests/docker/smoke-test.sh +++ b/tests/docker/smoke-test.sh @@ -27,9 +27,6 @@ SUITE="smoketest" export LNT_DB_PASSWORD="smoke-test-password" export LNT_AUTH_TOKEN="${AUTH_TOKEN}" export LNT_HOST_PORT="${HOST_PORT}" -# Use 1 worker to avoid multi-worker schema cache reload issues -# (the test creates a suite at runtime; other workers wouldn't see it). -export GUNICORN_WORKERS=1 # Common compose flags: use isolated project name. COMPOSE_CMD=(docker compose -f "$COMPOSE_FILE" -p "$PROJECT_NAME") diff --git a/tests/server/api/v5/test_test_suites.py b/tests/server/api/v5/test_test_suites.py index b9a6759e6..853eaf8b8 100644 --- a/tests/server/api/v5/test_test_suites.py +++ b/tests/server/api/v5/test_test_suites.py @@ -776,11 +776,6 @@ def test_stale_version_triggers_reload(self): db = self.app.instance.get_database("default") suites_before = set(db.testsuite.keys()) - # We need at least one suite so we can hit a per-suite endpoint - # that triggers the staleness check via get_suite(). - self.assertIn('nts', suites_before, - "need the built-in 'nts' suite for this test") - # Artificially bump the DB version to simulate another worker session = db.make_session() row = session.query(V5SchemaVersion).get(1) @@ -790,12 +785,10 @@ def test_stale_version_triggers_reload(self): bumped_version = row.version session.close() - # The schema version check happens inside get_suite(), which is - # called by the middleware when a per-suite endpoint is accessed. - # The list endpoint (/api/v5/test-suites/) does NOT resolve a - # testsuite, so it won't trigger the check. Hit a per-suite - # endpoint instead. - resp = self.client.get('/api/v5/nts/tests') + # Middleware calls ensure_fresh() on every /api/v5/ request, so + # even non-per-suite endpoints like the list endpoint trigger a + # schema reload when the version is stale. + resp = self.client.get('/api/v5/test-suites/') self.assertEqual(resp.status_code, 200) # After reload, the cached version should match the DB diff --git a/tests/server/db/v5/test_import.py b/tests/server/db/v5/test_import.py index 058f331d7..9d4d47d4e 100644 --- a/tests/server/db/v5/test_import.py +++ b/tests/server/db/v5/test_import.py @@ -722,7 +722,10 @@ def test_staleness_detection(self): session.commit() session.close() - # v5db2 should detect staleness on next get_suite call + # v5db2 should detect staleness via ensure_fresh() + session2 = v5db2.make_session() + v5db2.ensure_fresh(session2) + session2.close() result = v5db2.get_suite("stale_test") self.assertIsNone(result) From df803425736b9237dc17a60cc6ad53036d8d7355 Mon Sep 17 00:00:00 2001 From: Louis Dionne Date: Wed, 15 Apr 2026 11:38:29 -0400 Subject: [PATCH 063/143] [Tests+UI] Restore items dropped during v5 DB layer rebase Restore test coverage and a views.py fix that were unintentionally dropped when rebasing v5-with-new-db-layer onto v5: - views.py: Restore _v5_url_base()/_v4_url() helpers for proper sub-path deployment; remove ts_data(ts) call that crashes on v5-only instances (accesses v4-only ts.Baseline) - test_integration.py: Add test_07_commit_created_implicitly, assert run_parameters in run detail, add TestQueryWorkflow (query + time-range filtering via API-level helpers) - test_spa_shell_v5only.py: Restore v5-only SPA shell test - create.shtest: Restore v5 instance creation test section Co-Authored-By: Claude Opus 4.6 (1M context) --- lnt/server/ui/v5/views.py | 31 ++++-- tests/lnttool/create.shtest | 18 ++++ tests/server/api/v5/test_integration.py | 101 ++++++++++++++++++++ tests/server/ui/v5/test_spa_shell_v5only.py | 89 +++++++++++++++++ 4 files changed, 233 insertions(+), 6 deletions(-) create mode 100644 tests/server/ui/v5/test_spa_shell_v5only.py diff --git a/lnt/server/ui/v5/views.py b/lnt/server/ui/v5/views.py index 238ffef13..bf3cb43ce 100644 --- a/lnt/server/ui/v5/views.py +++ b/lnt/server/ui/v5/views.py @@ -1,15 +1,36 @@ from flask import g, render_template, request from . import v5_frontend, _setup_testsuite -from lnt.server.ui.views import ts_data from lnt.server.ui.decorators import _make_db_session +def _v5_url_base(): + """Compute the LNT URL base for the v5 SPA. + + Uses the v4 blueprint's index URL when available (keeps parity with + v4 instances), otherwise falls back to the request's script root. + """ + try: + from flask import url_for + return url_for('lnt.index', _external=False).rstrip('/') + except Exception: + return request.script_root + + +def _v4_url(): + """Return the v4 UI root URL, or empty string if v4 is not available.""" + try: + from flask import url_for + return url_for('lnt.index') + except Exception: + return '' + + def _v5_render(**kwargs): """Render the v5 SPA shell with common template variables.""" return render_template("v5_app.html", - lnt_url_base='', - v4_url='', + lnt_url_base=_v5_url_base(), + v4_url=_v4_url(), **kwargs) @@ -46,9 +67,7 @@ def v5_app(testsuite_name, subpath=None): _setup_testsuite(testsuite_name) try: ts = request.get_testsuite() - data = ts_data(ts) db = request.get_db() - data['testsuites'] = sorted(db.testsuite.keys()) - return _v5_render(**data) + return _v5_render(testsuites=sorted(db.testsuite.keys())) finally: request.session.close() diff --git a/tests/lnttool/create.shtest b/tests/lnttool/create.shtest index 296b93952..05ce13703 100644 --- a/tests/lnttool/create.shtest +++ b/tests/lnttool/create.shtest @@ -85,3 +85,21 @@ lnt import "${TMPBASE}/instance" "${SHARED_INPUTS}/sample-a-small.plist" \ | filecheck --check-prefix CHECK-IMPORT "${THIS_FILE}" # CHECK-IMPORT: Import succeeded. + +############################################################################### +# v5 creation: --db-version 5.0 writes db_version into the config and +# initializes the v5 global tables. +############################################################################### + +# Create the database first (Postgres requires it to exist). +psql "${LNT_TEST_DB_URI}/postgres" -c "CREATE DATABASE lnt_test_v5" 2>/dev/null || true + +lnt create "${TMPBASE}/v5inst" \ + --db-dir "${LNT_TEST_DB_URI}" \ + --default-db "lnt_test_v5" \ + --db-version 5.0 \ + --api-auth-token test_token + +filecheck --check-prefix CHECK-V5 "${THIS_FILE}" < "${TMPBASE}/v5inst/lnt.cfg" + +# CHECK-V5: 'default' : { 'db_version': '5.0', 'path' : '{{.*}}lnt_test_v5' }, diff --git a/tests/server/api/v5/test_integration.py b/tests/server/api/v5/test_integration.py index f38ee5cf5..a46c1fc20 100644 --- a/tests/server/api/v5/test_integration.py +++ b/tests/server/api/v5/test_integration.py @@ -104,6 +104,7 @@ def test_03_run_detail_is_correct(self): data['commit'], self._revision, "Run detail commit mismatch") self.assertIn('submitted_at', data) + self.assertIn('run_parameters', data) def test_04_run_samples_returned(self): """GET /runs/{uuid}/samples returns the submitted samples.""" @@ -149,6 +150,14 @@ def test_06_tests_created_implicitly(self): self.assertTrue(has_benchmark1, f"benchmark1 test not found in tests list: {names}") + def test_07_commit_created_implicitly(self): + """The commit is implicitly created by the run submission.""" + resp = self.client.get( + PREFIX + f'/commits/{self._revision}') + self.assertEqual(resp.status_code, 200, + "Commit not found after run submission") + self.assertEqual(resp.get_json()['commit'], self._revision) + # ----------------------------------------------------------------------- # 2. TestAPIKeyLifecycle @@ -506,5 +515,97 @@ def test_cors_on_options_preflight(self): "OPTIONS response missing Authorization in Allow-Headers") +# ----------------------------------------------------------------------- +# 7. TestQueryWorkflow +# ----------------------------------------------------------------------- + +class TestQueryWorkflow(unittest.TestCase): + """Submit runs with data, then query them via POST /query. + + This workflow exercises: + POST /runs (submit with data) + PATCH /commits/{value} (assign ordinals) + POST /query (time-series query) + """ + + app = None + client = None + + _machine = None + _test = None + _commits = None + + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.app = create_app(sys.argv[1]) + cls.client = create_client(cls.app) + cls._machine = f'query-wf-m-{uuid.uuid4().hex[:8]}' + cls._test = f'query-wf/test/{uuid.uuid4().hex[:8]}' + cls._commits = [] + + import datetime + from v5_test_helpers import ( + create_machine, create_commit, create_run, + create_test, create_sample, + ) + db = cls.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + machine = create_machine(session, ts, name=cls._machine) + test = create_test(session, ts, name=cls._test) + for i in range(5): + c = create_commit(session, ts, + commit=f'qwf-c-{uuid.uuid4().hex[:8]}') + ts.update_commit(session, c, ordinal=5000 + i) + run = create_run(session, ts, machine, c, + submitted_at=datetime.datetime( + 2024, 1, 1 + i, 12, 0, 0)) + create_sample(session, ts, run, test, + execution_time=10.0 + i) + cls._commits.append(c.commit) + session.commit() + session.close() + + def test_query_returns_all_data(self): + """POST /query returns all 5 submitted data points.""" + resp = self.client.post( + PREFIX + '/query', + json={ + 'metric': 'execution_time', + 'machine': self._machine, + 'test': [self._test], + }, + ) + self.assertEqual(resp.status_code, 200, + f"POST /query returned {resp.status_code}") + items = resp.get_json()['items'] + self.assertEqual(len(items), 5, + f"Expected 5 items, got {len(items)}") + for item in items: + self.assertIn('commit', item) + self.assertIn('ordinal', item) + self.assertIn('submitted_at', item) + self.assertNotIn('order', item, + "v4 'order' field leaked into v5 response") + self.assertNotIn('timestamp', item, + "v4 'timestamp' field leaked into v5 response") + + def test_query_filter_by_time_range(self): + """POST /query with after_time/before_time filters correctly.""" + resp = self.client.post( + PREFIX + '/query', + json={ + 'metric': 'execution_time', + 'machine': self._machine, + 'after_time': '2024-01-02T00:00:00', + 'before_time': '2024-01-04T00:00:00', + }, + ) + self.assertEqual(resp.status_code, 200) + items = resp.get_json()['items'] + self.assertEqual(len(items), 2) + + if __name__ == '__main__': unittest.main(argv=[sys.argv[0]], exit=True) diff --git a/tests/server/ui/v5/test_spa_shell_v5only.py b/tests/server/ui/v5/test_spa_shell_v5only.py new file mode 100644 index 000000000..a025f3cc4 --- /dev/null +++ b/tests/server/ui/v5/test_spa_shell_v5only.py @@ -0,0 +1,89 @@ +# Tests for the v5 SPA shell running on a v5-only instance (no v4 blueprint). +# Verifies that all SPA routes serve correctly without the v4 frontend. +# +# RUN: rm -rf %t.instance %t.pg.log +# RUN: %{utils}/with_postgres.sh %t.pg.log \ +# RUN: %{utils}/with_temporary_instance.py %t.instance --db-version 5.0 \ +# RUN: -- python %s %t.instance +# END. + +import sys +import unittest + +import lnt.server.ui.app + +INSTANCE_PATH = sys.argv.pop(1) + + +class TestSPAShellV5Only(unittest.TestCase): + """Test SPA shell on a v5-only instance (v4 blueprint not registered).""" + + @classmethod + def setUpClass(cls): + cls.app = lnt.server.ui.app.App.create_standalone(INSTANCE_PATH) + cls.app.testing = True + cls.client = cls.app.test_client() + + def test_dashboard_route(self): + resp = self.client.get('/v5/') + self.assertEqual(resp.status_code, 200) + html = resp.get_data(as_text=True) + self.assertIn('id="v5-app"', html) + self.assertIn('data-testsuite=""', html) + + def test_graph_route(self): + resp = self.client.get('/v5/graph') + self.assertEqual(resp.status_code, 200) + html = resp.get_data(as_text=True) + self.assertIn('id="v5-app"', html) + + def test_compare_route(self): + resp = self.client.get('/v5/compare') + self.assertEqual(resp.status_code, 200) + html = resp.get_data(as_text=True) + self.assertIn('id="v5-app"', html) + + def test_admin_route(self): + resp = self.client.get('/v5/admin') + self.assertEqual(resp.status_code, 200) + html = resp.get_data(as_text=True) + self.assertIn('id="v5-app"', html) + self.assertIn('data-testsuite=""', html) + + def test_test_suites_route(self): + resp = self.client.get('/v5/test-suites') + self.assertEqual(resp.status_code, 200) + html = resp.get_data(as_text=True) + self.assertIn('id="v5-app"', html) + + def test_suite_scoped_route(self): + resp = self.client.get('/v5/nts/') + self.assertEqual(resp.status_code, 200) + html = resp.get_data(as_text=True) + self.assertIn('id="v5-app"', html) + self.assertIn('data-testsuite="nts"', html) + + def test_suite_scoped_subpath(self): + resp = self.client.get('/v5/nts/machines/some-machine') + self.assertEqual(resp.status_code, 200) + + def test_template_loads_v5_assets(self): + resp = self.client.get('/v5/') + html = resp.get_data(as_text=True) + self.assertIn('v5/v5.js', html) + self.assertIn('v5/v5.css', html) + + def test_template_has_lnt_url_base(self): + resp = self.client.get('/v5/') + html = resp.get_data(as_text=True) + self.assertIn('var lnt_url_base=', html) + + def test_v4_url_is_empty(self): + """On a v5-only instance, the v4 link should be empty.""" + resp = self.client.get('/v5/') + html = resp.get_data(as_text=True) + self.assertIn('data-v4-url=""', html) + + +if __name__ == '__main__': + unittest.main() From af1c7d93ecef77230e7ea6ed8d20e28a7bf0a78d Mon Sep 17 00:00:00 2001 From: Louis Dionne Date: Wed, 15 Apr 2026 00:22:32 -0400 Subject: [PATCH 064/143] [Docs] Merge regression workflow redesign into main design docs Codify the regression/field-change model changes discussed in v5-regression-workflow-changes.md into the authoritative design and implementation plan documents, then delete the discussion file. Key changes: - Regression states reduced from 7 to 5 (sequential 0-4): detected, active, not_to_be_fixed, fixed, false_positive - Removed: staged, ignored, detected_fixed - Added notes (TEXT) column to Regression (detail response only) - Merge now deletes source regressions (instead of marking ignored) - Field change list returns all FCs enriched with regression_uuids - New ?assigned=true/false filter on field change list - FieldChanges documented as stateless observations Co-Authored-By: Claude Opus 4.6 (1M context) --- docs/design/v5-api.md | 28 ++- docs/design/v5-db.md | 19 ++- docs/design/v5-regression-workflow-changes.md | 160 ------------------ docs/design/v5-ui.md | 2 +- docs/v5-api-implementation-plan.md | 21 +-- docs/v5-db-implementation-plan.md | 10 +- 6 files changed, 47 insertions(+), 193 deletions(-) delete mode 100644 docs/design/v5-regression-workflow-changes.md diff --git a/docs/design/v5-api.md b/docs/design/v5-api.md index ed78a0a37..955ce3e9d 100644 --- a/docs/design/v5-api.md +++ b/docs/design/v5-api.md @@ -72,11 +72,11 @@ Profiles are submitted as base64-encoded data within the run submission payload Regressions GET /regressions — List (cursor-paginated, filterable by state=, machine=, test=) -POST /regressions — Create from field changes +POST /regressions — Create from field changes (accepts title, bug, notes, state) GET /regressions/{uuid} — Detail (see response contents below) -PATCH /regressions/{uuid} — Update title, bug URL, state +PATCH /regressions/{uuid} — Update title, bug URL, state, notes DELETE /regressions/{uuid} — Delete -POST /regressions/{uuid}/merge — Merge source regressions into this one +POST /regressions/{uuid}/merge — Merge source regressions into this one (sources are deleted) POST /regressions/{uuid}/split — Split field changes into a new regression GET /regressions/{uuid}/indicators — List field changes (cursor-paginated) POST /regressions/{uuid}/indicators — Add field change @@ -84,25 +84,36 @@ DELETE /regressions/{uuid}/indicators/{fc_uuid} — Remove field change Regressions are identified by server-generated UUID (schema migration required). Regression states (string enum): -detected, staged, active, not_to_be_fixed, ignored, detected_fixed, fixed +detected, active, not_to_be_fixed, fixed, false_positive State transitions are unconstrained — any state can be set to any other state via PATCH. Regression detail response (GET /regressions/{uuid}) includes: -- uuid, title, bug, state +- uuid, title, bug, state, notes - Embedded list of indicators, each containing: - field_change_uuid - test, machine, metric - old_value, new_value - start_commit and end_commit (commit identity strings) +The `notes` field (free-text, for investigation findings, A/B results, root +cause analysis, false_positive reasoning, etc.) is included in the detail +response only, not in list responses. + Field Changes (triage) -GET /field-changes — List unassigned field changes (cursor-paginated, filterable by machine=, test=, metric=) +GET /field-changes — List field changes (cursor-paginated, filterable by machine=, test=, metric=, assigned=) POST /field-changes — Create a field change programmatically (references machine, test, metric, and commits by name) -Field changes are identified by server-generated UUID. +Field changes are identified by server-generated UUID. They are stateless +observations — they have no lifecycle of their own. Creating a field change requires: machine (name), test (name), metric (name), old_value, new_value, start_commit, end_commit. All references are resolved by name/value, not internal ID. +Field change response shape (GET list and embedded in regression indicators): +- uuid, test, machine, metric +- old_value, new_value +- start_commit, end_commit (commit identity strings) +- regression_uuids (list of regression UUIDs this FC belongs to, empty if unassigned) + Time Series POST /query @@ -135,7 +146,7 @@ There are no separate /fields or /schema endpoints. R4: Pagination -- Cursor-based pagination for unbounded lists: runs, tests, orders, samples, field changes, regressions, regression indicators, time series +- Cursor-based pagination for unbounded lists: runs, tests, commits, samples, field changes, regressions, regression indicators, time series - Simple offset-based or unpaginated for bounded/small lists: machines, API keys - Cursor-paginated response envelope: {"items": [...], "cursor": {"next": "...", "previous": "..."}} - Default page size with configurable limit parameter @@ -148,6 +159,7 @@ R5: Filtering and Sorting - machine=, test=, metric=, name_contains=, name_prefix= - after=, before= (for timestamps and order values) - state= (for regressions, supports multiple values: ?state=active&state=detected) + - assigned= (for field changes, boolean: true/false) - has_profile=true (for samples) - sort= (prefix with - for descending: sort=-start_time) - Exact filters and available sort fields defined per endpoint in the OpenAPI spec diff --git a/docs/design/v5-db.md b/docs/design/v5-db.md index 2fd19dd75..e741ed7e0 100644 --- a/docs/design/v5-db.md +++ b/docs/design/v5-db.md @@ -233,18 +233,17 @@ Per-suite tables are dynamically named (e.g., `nts_Commit`, `nts_Run`). | title | String(256) | nullable | | bug | String(256) | nullable | | state | Integer | not null, indexed | +| notes | Text | nullable | Regression state values: | Value | Name | |-------|------------------| | 0 | detected | -| 1 | staged | -| 2 | active | -| 3 | not_to_be_fixed | -| 4 | ignored | -| 5 | fixed | -| 6 | detected_fixed | +| 1 | active | +| 2 | not_to_be_fixed | +| 3 | fixed | +| 4 | false_positive | The DB layer validates state values on create and update. @@ -262,9 +261,11 @@ The DB layer validates state values on create and update. ### Tables dropped from v4 - **Baseline**: v5 comparisons are stateless API operations. -- **ChangeIgnore**: There is no "ignore" state on FieldChanges. If a field - change is not relevant, it should not be created. The external process that - creates field changes is responsible for filtering. +- **ChangeIgnore**: There is no "ignore" state on FieldChanges. FieldChanges + are stateless observations — they have no lifecycle of their own. Dismissal + of noise happens at the regression level: group field changes into a + `false_positive` regression with notes explaining the reasoning. The external + process that creates field changes is responsible for filtering upstream. - **Profile**: Profiling is a separate concern. - **Order**: Replaced by Commit. diff --git a/docs/design/v5-regression-workflow-changes.md b/docs/design/v5-regression-workflow-changes.md deleted file mode 100644 index 4cd93423f..000000000 --- a/docs/design/v5-regression-workflow-changes.md +++ /dev/null @@ -1,160 +0,0 @@ -# Regression & Field Change Workflow: Discussion Summary & Plan - -## Origin - -Feature requests from a colleague using an AI agent to investigate libc++ -performance regressions on an LNT v5 instance (`lnt-feature-requests.md`). -The agent detects regressions externally, performs A/B testing, and needs to -write findings back into LNT. The v5 API's data model is too thin — only a -256-char title and a bug URL on regressions, no way to annotate field changes. - -Three original requests: -1. Add a `notes` field to Regression (free-text, for investigation findings) -2. Add a `reason` parameter to POST /field-changes/{uuid}/ignore -3. Add a `false_positive` state to the Regression state enum - -## Discussion & Design Decisions - -### Rethinking the model for external agents - -LNT is moving toward being a data store for perf data + regression tracking, -with analysis happening externally (AI agents). This changes the picture: - -- **`staged` and `detected_fixed` are dead states.** Both assumed LNT does - auto-detection. `staged` = "approved, waiting for cooldown" (cooldown from - what?). `detected_fixed` = "system noticed metric recovered." Neither has - working automation behind it. Remove from v5 API. - -- **`ignored` is redundant.** With `not_to_be_fixed` (real, won't fix) and - `false_positive` (not real), there's no remaining semantic space for - `ignored`. Remove from v5 API. - -- **FieldChanges are pure stateless data.** A FC is an observation: "metric X - changed by Y% between orders A and B on machine M." It doesn't need its own - lifecycle. The only relationship that matters is whether it's linked to a - regression (via RegressionIndicator). - -- **ChangeIgnore is not needed in v5.** It was a triage filter for - auto-detected signals ("system flagged this, but it's noise"). In the - external-agent world, the agent creates FCs deliberately — it wouldn't - create one just to ignore it. Dismissal of FCs happens at the regression - level: group them into a `false_positive` regression with notes. - -- **The ignore endpoints are removed.** POST /field-changes/{uuid}/ignore - and DELETE /field-changes/{uuid}/ignore are gone. Feature request #2 - (reason on ignore) is satisfied by regression `notes` on a `false_positive` - regression. - -### Final Regression state machine (v5 API) - -| State | DB value | Meaning | -|-------------------|----------|--------------------------------------| -| `detected` | 0 | Newly flagged, needs review | -| `active` | 10 | Confirmed real, needs investigation | -| `not_to_be_fixed` | 20 | Real regression, accepted/won't fix | -| `fixed` | 22 | Resolved | -| `false_positive` | 24 | Noise / detection error | - -Removed from v5 API (kept in DB/v4 code for backwards compat): -- `staged` (1) — unused auto-detection workflow -- `ignored` (21) — redundant with not_to_be_fixed + false_positive -- `detected_fixed` (23) — unused auto-detection workflow - -The `state_to_api()` function returns `'unknown_N'` for unmapped DB values. - -### Final FieldChange model - -FCs have no state. Properties: -- Identity: uuid -- What changed: test, machine, metric (field) -- Between when: start_order, end_order -- By how much: old_value, new_value -- Context: run (optional FK) -- Relationship: → RegressionIndicator → Regression (many-to-many) - -GET /field-changes returns ALL field changes (no exclusions), enriched with -`regression_uuids` (list of regression UUIDs the FC belongs to, empty if -unassigned). Existing filters (machine, test, metric) still work. - -### Notes on Regression - -New `notes` TEXT column. Nullable, no length limit. Accepted in POST -/regressions and PATCH /regressions/{uuid}. Returned in all GET responses -(list and detail). This is where investigation findings go — root cause -analysis, A/B test results, links to related changes, reasons for -false_positive classification, etc. - -## Implementation Plan - -### Commit 1: Database & Model Changes - -**Migration** (next upgrade script): -- Add `Notes` TEXT column to each test suite's Regression table -- Nullable, no backfill needed - -**Model** (Regression): -- Add `notes = Column("Notes", Text)` after `state` -- Update `__init__` to accept optional `notes=None` - -**State machine** (RegressionState): -- Add `FALSE_POSITIVE = 24` -- Add to `names` dict -- Do NOT remove existing constants (v4 references them) - -### Commit 2: API Changes - -**State mapping** (schemas/regressions.py STATE_TO_DB): -- Remove `'staged': 1`, `'ignored': 21`, `'detected_fixed': 23` -- Add `'false_positive': 24` - -**Regression schemas**: -- Add `notes` to create, update, list, and detail schemas - -**Regression endpoints**: -- Serialize `notes` in list and detail responses -- Accept `notes` in POST (create) and PATCH (update) - -**Field change endpoint** (GET /field-changes): -- Remove LEFT JOIN exclusion logic (ChangeIgnore + RegressionIndicator) -- Return all FCs, enriched with `regression_uuids` -- Batch query RegressionIndicator JOIN Regression after pagination - -**Remove ignore endpoints**: -- Delete POST /field-changes/{uuid}/ignore -- Delete DELETE /field-changes/{uuid}/ignore -- Remove related schemas (FieldChangeIgnoreResponseSchema) - -**Field change response shape**: -```json -{ - "uuid": "...", - "test": "...", - "machine": "...", - "metric": "...", - "old_value": 1.0, - "new_value": 2.0, - "start_order": "rev1", - "end_order": "rev2", - "run_uuid": "...", - "regression_uuids": ["uuid1", "uuid2"] -} -``` - -**Tests**: -- State mapping: false_positive round-trips; staged/ignored/detected_fixed - return unknown_N / None -- Regressions: notes CRUD (create, read list+detail, update, null); - false_positive accepted; staged/ignored/detected_fixed rejected (422) -- Field changes: list returns all FCs; regression_uuids enrichment correct; - ignore endpoints gone (404); existing filters + pagination still work - -### Commit 3: Design & Implementation Doc Updates - -- Update regression states in docs/design/v5-api.md and - docs/v5-api-implementation-plan.md -- Add notes to regression model docs -- Update field-changes section: remove ignore, list returns all with - regression_uuids -- Fix field naming inconsistency in design doc: test_name→test, - machine_name→machine, field_name→metric -- Document philosophy: FCs are stateless data, workflow at regression level diff --git a/docs/design/v5-ui.md b/docs/design/v5-ui.md index a33076902..5cec7a2ca 100644 --- a/docs/design/v5-ui.md +++ b/docs/design/v5-ui.md @@ -68,7 +68,7 @@ The shell template (`v5_app.html`) is a standalone HTML page (it does NOT extend /v5/{ts}/machines/{name} Machine Detail /v5/{ts}/runs/{uuid} Run Detail /v5/{ts}/commits/{value} Commit Detail -/v5/{ts}/regressions?state=... Regression List +/v5/{ts}/regressions?state=... Regression List (states: detected, active, not_to_be_fixed, fixed, false_positive) /v5/{ts}/regressions/{uuid} Regression Detail /v5/{ts}/field-changes Field Change Triage /v5/graph?suite={ts}&machine=... Graph (time series) — suite-agnostic diff --git a/docs/v5-api-implementation-plan.md b/docs/v5-api-implementation-plan.md index 5bba31c09..dfae527bb 100644 --- a/docs/v5-api-implementation-plan.md +++ b/docs/v5-api-implementation-plan.md @@ -494,14 +494,14 @@ DELETE /api/v5/{ts}/regressions/{uuid}/indicators/{fc_uuid} — Remove indicato **Key design decisions:** - Identified by **UUID** (NOT integer ID). Requires migration. - State mapping: API strings ↔ DB integers: - `detected`↔0, `staged`↔1, `active`↔10, `not_to_be_fixed`↔20, - `ignored`↔21, `fixed`↔22, `detected_fixed`↔23 + `detected`↔0, `active`↔1, `not_to_be_fixed`↔2, + `fixed`↔3, `false_positive`↔4 - State transitions unconstrained. **Detail response** includes embedded indicators: ```json { - "uuid": "...", "title": "...", "bug": "...", "state": "active", + "uuid": "...", "title": "...", "bug": "...", "state": "active", "notes": "...", "indicators": [ { "field_change_uuid": "...", @@ -513,8 +513,9 @@ DELETE /api/v5/{ts}/regressions/{uuid}/indicators/{fc_uuid} — Remove indicato } ``` -**Merge**: target absorbs sources. Sources marked as IGNORED. Indicators moved to target. -Deduplicate indicators (don't link same field change twice). Validate: cannot merge into self. +**Merge**: target absorbs sources. Sources are deleted after their indicators +are moved to the target. Deduplicate indicators (don't link same field change twice). +Validate: cannot merge into self. Request body uses UUIDs: `{"source_regression_uuids": ["...", "..."]}`. **Split**: move specified field changes to a new regression. Validate: cannot split ALL @@ -530,16 +531,16 @@ Auth: read=GET, triage=POST/PATCH/DELETE/merge/split/indicators. **Endpoints:** ``` -GET /api/v5/{ts}/field-changes — List unassigned (cursor-paginated) +GET /api/v5/{ts}/field-changes — List all field changes (cursor-paginated) POST /api/v5/{ts}/field-changes — Create a field change ``` **Key design decisions:** - Identified by **UUID**. -- "Unassigned" = no RegressionIndicator (LEFT JOIN + IS NULL pattern). - No ChangeIgnore in v5 — field changes that are not relevant should not - be created (the external process is responsible for filtering). -- Filters: `machine=`, `test=`, `metric=` +- Returns all FCs enriched with `regression_uuids` (list of regression UUIDs + the FC belongs to, empty if unassigned). Filter `?assigned=true/false` + controls inclusion. No ChangeIgnore in v5. +- Filters: `machine=`, `test=`, `metric=`, `assigned=` - Auth: read=GET, submit=POST (create). **POST /field-changes (create):** diff --git a/docs/v5-db-implementation-plan.md b/docs/v5-db-implementation-plan.md index 0ab13907c..ad6adc06d 100644 --- a/docs/v5-db-implementation-plan.md +++ b/docs/v5-db-implementation-plan.md @@ -54,7 +54,7 @@ The DB layer provides filtering, sorting, and limit only. ### 1b.3 Regression state validation -Add `VALID_REGRESSION_STATES` constant (mapping integers 0-6 to state names) +Add `VALID_REGRESSION_STATES` constant (mapping integers 0-4 to state names) and validate in `create_regression()` and `update_regression()`. ### 1b.4 Add missing CRUD methods to `V5TestSuiteDB` @@ -337,8 +337,8 @@ FK on v5 FieldChange). ### 2.8 Endpoint: Regressions (`regressions.py`) **State mapping**: Update `STATE_TO_DB` to v5 integer values: -`detected=0, staged=1, active=2, not_to_be_fixed=3, ignored=4, fixed=5, -detected_fixed=6`. +`detected=0, active=1, not_to_be_fixed=2, fixed=3, +false_positive=4`. **`POST /regressions`** — Use `ts.create_regression(session, title, [fc.id ...], bug=bug, state=state)`. @@ -347,8 +347,8 @@ detected_fixed=6`. **`DELETE /regressions/{uuid}`** — Use `ts.delete_regression()`. -**`POST .../merge`** — Use `ts.update_regression()` for state changes. -Keep indicator-moving logic using `ts.RegressionIndicator` queries. +**`POST .../merge`** — Delete source regressions after moving their indicators +to the target. Keep indicator-moving logic using `ts.RegressionIndicator` queries. **`POST .../split`** — Use `ts.create_regression(session, title, [], ...)` then move indicators. From 8f184cd226dc6eb85442b3b2deffd3e384529433 Mon Sep 17 00:00:00 2001 From: Louis Dionne Date: Wed, 15 Apr 2026 09:24:56 -0400 Subject: [PATCH 065/143] [Docs] Redesign regression model: drop FieldChange, simplify indicators MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Redesign the regression system based on the principle that LNT should be a lightweight bridge to external bug trackers, not a bug tracker itself. Key changes: - Drop FieldChange table entirely — regressions directly reference affected machines, tests, and metrics via RegressionIndicator - RegressionIndicator now contains (machine_id, test_id, metric) directly instead of pointing to a FieldChange - Single nullable commit FK on Regression (suspected introduction point) replaces start_commit/end_commit ranges on FieldChange - Drop old_value/new_value (derived stats that don't belong in the model) - Drop merge/split endpoints (composable from CRUD operations) - Drop all /field-changes API endpoints - Add notes TEXT column to Regression - Design full Regression List and Detail UI pages (replacing stubs) - Add cross-page integration: regressions on commit, run, machine detail pages, test suites tab, graph annotations, compare page panel Co-Authored-By: Claude Opus 4.6 (1M context) --- docs/design/v5-api.md | 83 +++++++++++++------------- docs/design/v5-db.md | 59 +++++++------------ docs/design/v5-ui.md | 95 +++++++++++++++++++++++------- docs/v5-api-implementation-plan.md | 73 ++++++----------------- docs/v5-db-implementation-plan.md | 48 ++++++--------- docs/v5-submission-guide.md | 2 +- 6 files changed, 173 insertions(+), 187 deletions(-) diff --git a/docs/design/v5-api.md b/docs/design/v5-api.md index 955ce3e9d..0daa96530 100644 --- a/docs/design/v5-api.md +++ b/docs/design/v5-api.md @@ -13,7 +13,7 @@ R2: URL Structure and Identifiers - Base path: /api/v5/{testsuite}/ - Always uses the default database (no db_ prefix) -- Entities addressed by natural keys (machine name, test name) or server-generated UUIDs (runs, regressions, field changes) — never by internal auto-increment database IDs +- Entities addressed by natural keys (machine name, test name) or server-generated UUIDs (runs, regressions) — never by internal auto-increment database IDs - A discovery endpoint at GET /api/v5/ lists available test suites with links to their resources R3: Entity Endpoints @@ -34,7 +34,7 @@ GET /commits — List (cursor-paginated, searchable) POST /commits — Create with metadata (commit_fields) GET /commits/{value} — Detail (includes previous/next commit by ordinal) PATCH /commits/{value} — Update ordinal and/or commit_fields -DELETE /commits/{value} — Delete commit (cascades to runs/samples; 409 if referenced by field changes) +DELETE /commits/{value} — Delete commit (cascades to runs/samples; 409 if referenced by regressions) The {value} in the path is the commit identity string. Commits are also created implicitly during run submission. Ordinals are always NULL on creation and assigned exclusively via PATCH (see D11 in v5-db.md). @@ -44,7 +44,7 @@ GET /runs — List (cursor-paginated, filterable by m POST /runs — Submit run (server generates UUID, returns it) GET /runs/{uuid} — Detail DELETE /runs/{uuid} — Delete run -The UUID is a new field, generated server-side on submission. This requires a database schema migration to add the column. The submission endpoint requires JSON format with format_version '2'. Legacy formats (v0, v1) and non-JSON payloads are rejected. +The UUID is a new field, generated server-side on submission. The submission endpoint requires JSON format with format_version '5'. Legacy formats (v0, v1, v2) and non-JSON payloads are rejected. Tests @@ -71,48 +71,47 @@ Profiles are submitted as base64-encoded data within the run submission payload Regressions -GET /regressions — List (cursor-paginated, filterable by state=, machine=, test=) -POST /regressions — Create from field changes (accepts title, bug, notes, state) -GET /regressions/{uuid} — Detail (see response contents below) -PATCH /regressions/{uuid} — Update title, bug URL, state, notes -DELETE /regressions/{uuid} — Delete -POST /regressions/{uuid}/merge — Merge source regressions into this one (sources are deleted) -POST /regressions/{uuid}/split — Split field changes into a new regression -GET /regressions/{uuid}/indicators — List field changes (cursor-paginated) -POST /regressions/{uuid}/indicators — Add field change -DELETE /regressions/{uuid}/indicators/{fc_uuid} — Remove field change -Regressions are identified by server-generated UUID (schema migration required). +GET /regressions — List (cursor-paginated, filterable by state=, machine=, test=, metric=, commit=, has_commit=) +POST /regressions — Create (accepts title, bug, notes, state, commit, indicators) +GET /regressions/{uuid} — Detail (indicators embedded) +PATCH /regressions/{uuid} — Update title, bug, notes, state, commit +DELETE /regressions/{uuid} — Delete (cascades indicators) +POST /regressions/{uuid}/indicators — Add indicator(s) (batch) +DELETE /regressions/{uuid}/indicators — Remove indicator(s) (batch, UUIDs in body) + +Auth scopes: read=GET, triage=POST/PATCH/DELETE and indicator management. + +Regressions are identified by server-generated UUID. Regression states (string enum): detected, active, not_to_be_fixed, fixed, false_positive -State transitions are unconstrained — any state can be set to any other state via PATCH. +State transitions are unconstrained — any state can be set to any other +state via PATCH. -Regression detail response (GET /regressions/{uuid}) includes: -- uuid, title, bug, state, notes -- Embedded list of indicators, each containing: - - field_change_uuid - - test, machine, metric - - old_value, new_value - - start_commit and end_commit (commit identity strings) +Create request body: +- title (string, optional — auto-generated if omitted) +- bug (string, optional — URL to external bug tracker) +- notes (string, optional — investigation findings, A/B results, etc.) +- state (string, optional — default: detected) +- commit (string, optional — suspected introduction commit, resolved by value) +- indicators (array, optional — list of {machine, test, metric} objects, + all resolved by name) -The `notes` field (free-text, for investigation findings, A/B results, root -cause analysis, false_positive reasoning, etc.) is included in the detail -response only, not in list responses. +Detail response (GET /regressions/{uuid}): +- uuid, title, bug, notes, state +- commit (commit identity string, or null) +- indicators: list of {uuid, machine, test, metric} -Field Changes (triage) +List response items include: uuid, title, bug, state, commit, machine_count, test_count. +The notes field is included in detail responses only, not in list. -GET /field-changes — List field changes (cursor-paginated, filterable by machine=, test=, metric=, assigned=) -POST /field-changes — Create a field change programmatically (references machine, test, metric, and commits by name) -Field changes are identified by server-generated UUID. They are stateless -observations — they have no lifecycle of their own. -Creating a field change requires: machine (name), test (name), metric (name), old_value, new_value, start_commit, end_commit. All references are resolved by name/value, not internal ID. +Indicator add request (POST /regressions/{uuid}/indicators): +- Array of {machine, test, metric} objects. Each object is one indicator. + Duplicates (same regression+machine+test+metric) are silently ignored. -Field change response shape (GET list and embedded in regression indicators): -- uuid, test, machine, metric -- old_value, new_value -- start_commit, end_commit (commit identity strings) -- regression_uuids (list of regression UUIDs this FC belongs to, empty if unassigned) +Indicator remove request (DELETE /regressions/{uuid}/indicators): +- Body: {"indicator_uuids": ["...", "..."]} Time Series @@ -140,13 +139,13 @@ Schema and Fields Schema definitions and metric field metadata are returned as part of the test suite detail response (GET /api/v5/test-suites/{name}) rather than as standalone endpoints. -The response includes a "schema" object containing machine_fields, run_fields, and +The response includes a "schema" object containing machine_fields, commit_fields, and metrics (with name, type, display_name, unit, unit_abbrev, bigger_is_better for each). There are no separate /fields or /schema endpoints. R4: Pagination -- Cursor-based pagination for unbounded lists: runs, tests, commits, samples, field changes, regressions, regression indicators, time series +- Cursor-based pagination for unbounded lists: runs, tests, commits, samples, regressions, regression indicators, time series - Simple offset-based or unpaginated for bounded/small lists: machines, API keys - Cursor-paginated response envelope: {"items": [...], "cursor": {"next": "...", "previous": "..."}} - Default page size with configurable limit parameter @@ -159,7 +158,7 @@ R5: Filtering and Sorting - machine=, test=, metric=, name_contains=, name_prefix= - after=, before= (for timestamps and order values) - state= (for regressions, supports multiple values: ?state=active&state=detected) - - assigned= (for field changes, boolean: true/false) + - commit=, has_commit= (for regressions) - has_profile=true (for samples) - sort= (prefix with - for descending: sort=-start_time) - Exact filters and available sort fields defined per endpoint in the OpenAPI spec @@ -178,9 +177,9 @@ R7: Authentication and Authorization - Authorization: Bearer header on all requests - API keys with scopes (each scope includes all scopes above it): - read — all GET endpoints - - submit — submit runs (POST /runs), create orders (POST /orders) - - triage — modify regression state/title/bug, create/merge/split regressions, manage regression indicators - - manage — create/update/delete machines; update orders; delete runs + - submit — submit runs (POST /runs), create commits (POST /commits) + - triage — create/update/delete regressions, manage regression indicators + - manage — create/update/delete machines; update commits; delete runs - admin — create/revoke API keys - Keys stored hashed in the database - Admin endpoints (outside any test suite): diff --git a/docs/design/v5-db.md b/docs/design/v5-db.md index e741ed7e0..427df6b20 100644 --- a/docs/design/v5-db.md +++ b/docs/design/v5-db.md @@ -12,7 +12,7 @@ For the exploration and discussion that led to these decisions, see - The v5 DB layer lives in `lnt/server/db/v5/`, a self-contained package with its own schema parsing, models, and CRUD interface. - No imports from v4 DB code (`lnt.server.db.testsuite`, `testsuitedb`, - `v4db`, `fieldchange`, `regression`). The v5 package is fully independent. + `v4db`, `regression`). The v5 package is fully independent. - v4 and v5 coexist in the same codebase, selected by `db_version` in the LNT config file (`'0.4'` for v4, `'5.0'` for v5). - A v5 instance serves only v5 API endpoints. A v4 instance serves v4 views @@ -150,8 +150,8 @@ Per-suite tables are dynamically named (e.g., `nts_Commit`, `nts_Run`). - No `label` built-in column. If labeling is needed, define a `label` field in `commit_fields`. - Commits are deletable. Deleting a commit cascades to its runs (and their - samples). FieldChanges referencing a deleted commit must be deleted first - (the API enforces this). + samples). Commits referenced by a Regression's commit_id cannot be deleted + (the API returns 409). - Schema-defined `commit_fields` names must not collide with built-in column names (`id`, `commit`, `ordinal`). The schema parser rejects these. @@ -206,24 +206,6 @@ Per-suite tables are dynamically named (e.g., `nts_Commit`, `nts_Run`). - Dynamic columns from schema metrics: `real` → Float, `status` → Integer, `hash` → String(256). -### `{suite}_FieldChange` - -| Column | Type | Constraints | -|--------|------|-------------| -| id | Integer | PK | -| uuid | String(36) | unique, not null, indexed | -| test_id | Integer FK → Test | not null | -| machine_id | Integer FK → Machine | not null | -| field_name | String(256) | not null | -| start_commit_id | Integer FK → Commit | not null | -| end_commit_id | Integer FK → Commit | not null | -| old_value | Float | nullable | -| new_value | Float | nullable | - -- `field_name` is a plain string (metric name), not a FK to a metatable. - Simpler for an API-driven system. -- Compound index on `(machine_id, test_id, field_name)`. - ### `{suite}_Regression` | Column | Type | Constraints | @@ -232,8 +214,9 @@ Per-suite tables are dynamically named (e.g., `nts_Commit`, `nts_Run`). | uuid | String(36) | unique, not null, indexed | | title | String(256) | nullable | | bug | String(256) | nullable | -| state | Integer | not null, indexed | | notes | Text | nullable | +| state | Integer | not null, indexed | +| commit_id | Integer FK → Commit | nullable, indexed | Regression state values: @@ -252,20 +235,23 @@ The DB layer validates state values on create and update. | Column | Type | Constraints | |--------|------|-------------| | id | Integer | PK | +| uuid | String(36) | unique, not null, indexed | | regression_id | Integer FK → Regression | not null, indexed | -| field_change_id | Integer FK → FieldChange | not null | +| machine_id | Integer FK → Machine | not null | +| test_id | Integer FK → Test | not null | +| metric | String(256) | not null | -- Unique constraint on `(regression_id, field_change_id)`. -- Many-to-many join table between Regression and FieldChange. +- Unique constraint on `(regression_id, machine_id, test_id, metric)`. +- Each indicator represents one (machine, test, metric) combination + affected by the regression. ### Tables dropped from v4 - **Baseline**: v5 comparisons are stateless API operations. -- **ChangeIgnore**: There is no "ignore" state on FieldChanges. FieldChanges - are stateless observations — they have no lifecycle of their own. Dismissal - of noise happens at the regression level: group field changes into a - `false_positive` regression with notes explaining the reasoning. The external - process that creates field changes is responsible for filtering upstream. +- **ChangeIgnore**: Dropped. Noise dismissal happens at the regression level + via the `false_positive` state with notes. +- **FieldChange**: Dropped. Regressions directly reference affected machines, + tests, and metrics via RegressionIndicator. - **Profile**: Profiling is a separate concern. - **Order**: Replaced by Commit. @@ -331,13 +317,12 @@ Ordinals are set exclusively via PATCH (see D11). ## D8: No Regression Auto-Detection -All FieldChanges and Regressions are created, updated, and deleted via the API. -There is no `regenerate_fieldchanges_for_run()` or -`identify_related_changes()`. The v5 DB layer provides CRUD only. +All Regressions and their indicators are created, updated, and deleted via the +API. There is no auto-detection in the v5 DB layer — it provides CRUD only. Regression detection is the responsibility of an external process (a separate -tool or CI job) that analyzes time-series data and creates FieldChanges via the -API when it detects significant changes. +tool or AI agent) that analyzes time-series data and creates Regressions via +the API when it detects significant changes. ## D9: Search @@ -389,8 +374,8 @@ a v5 Postgres database: linked-list position becomes the ordinal. - v4 `tag` column on Order → a `label` commit_field (if defined in the schema). - Run.order_id → Run.commit_id; Run.start_time → Run.submitted_at. -- FieldChange.field_id FK → FieldChange.field_name string (resolved from - the SampleField metatable). +- v4 FieldChange + RegressionIndicator → v5 RegressionIndicator (machine_id, + test_id, metric resolved from FieldChange; field_change_id FK removed). - Baseline, ChangeIgnore, Profile tables are not migrated. diff --git a/docs/design/v5-ui.md b/docs/design/v5-ui.md index 5cec7a2ca..2bfc5e9ee 100644 --- a/docs/design/v5-ui.md +++ b/docs/design/v5-ui.md @@ -70,7 +70,6 @@ The shell template (`v5_app.html`) is a standalone HTML page (it does NOT extend /v5/{ts}/commits/{value} Commit Detail /v5/{ts}/regressions?state=... Regression List (states: detected, active, not_to_be_fixed, fixed, false_positive) /v5/{ts}/regressions/{uuid} Regression Detail -/v5/{ts}/field-changes Field Change Triage /v5/graph?suite={ts}&machine=... Graph (time series) — suite-agnostic /v5/compare?suite_a={ts}&... Compare — suite-agnostic /v5/admin Admin (API keys, schemas — not test-suite specific) @@ -127,7 +126,7 @@ The primary entry point for browsing test suite data. Suite-agnostic page with a **Suite picker**: A row of prominent card/button elements, one per test suite (from `data-testsuites`). Clicking a card selects it (highlighted) and shows the tab bar below. When no suite is selected, only the suite picker is visible. -**Tabs**: [Recent Activity] [Machines] [Runs] [Commits]. Default tab is Recent Activity. +**Tabs**: [Recent Activity] [Machines] [Runs] [Commits] [Regressions]. Default tab is Recent Activity. **URL state**: `?suite={ts}&tab=machines&search=foo&offset=0` — all state is in query params. On mount, reads params to restore state. On changes, updates URL via `replaceState`. @@ -137,12 +136,14 @@ The primary entry point for browsing test suite data. Suite-agnostic page with a | Machines | Searchable machine list with offset pagination | `GET machines?name_contains=...&limit=25&offset=...` | Name substring | | Runs | Run list with cursor pagination | `GET runs?machine=...&sort=-start_time&limit=25` | Machine name (exact) | | Commits | Commit list with cursor pagination | `GET commits?tag_prefix=...&limit=25` | Tag prefix | +| Regressions | Active regressions in this suite | `GET regressions?state=detected&state=active&limit=25` | State filter | **Columns per tab:** - **Recent Activity**: Machine, Commit (primary value), Start Time, UUID (truncated, linked) - **Machines**: Name (linked), Info (key-value summary) - **Runs**: UUID (truncated, linked), Machine, Commit (primary value), Start Time - **Commits**: Commit Value (primary field, linked), Tag +- **Regressions**: Title (linked), State (badge), Commit (linked), Machine count, Test count **Detail navigation**: Clicking an item navigates to the full suite-scoped detail page (e.g., `/v5/{ts}/machines/{name}`) via full page navigation. This crosses from suite-agnostic context to suite-scoped context. @@ -162,7 +163,9 @@ Deep dive into a single machine. Machine names are guaranteed unique. The delete section appears at the bottom. Clicking "Delete Machine" shows a confirmation prompt requiring the user to type the machine name. Deletion requires a valid API token with `manage` scope (set via the Settings panel in the nav bar). On success, navigates to the machine list. On auth failure (401/403), shows an error message reminding the user to set an API token with sufficient permissions. While the delete is in progress, a message reassures the user that deletion may take a while for machines with many runs. -**Links out**: Run Detail, Commit Detail, Graph (with machine pre-filled), Compare (with machine pre-selected). +**Links out**: Run Detail, Commit Detail, Graph (with machine pre-filled), Compare (with machine pre-selected), Regression Detail. + +**Active regressions**: Below the run history, a section showing non-resolved regressions (state: detected, active) with at least one indicator on this machine. Each links to its regression detail page. A "Show all" link navigates to the Regression List pre-filtered by this machine. ### 4. Run Detail — `/v5/{ts}/runs/{uuid}` @@ -184,7 +187,9 @@ A "Compare with..." button navigates to the Compare page with this run's machine The delete section appears at the bottom. Clicking "Delete Run" shows a confirmation prompt requiring the user to type the first 8 characters of the run UUID. Deletion requires a valid API token with `manage` scope. On success, navigates to the machine detail page. -**Links out**: Machine Detail, Commit Detail, Graph (test pre-filled), Profile, Compare (side A pre-selected). +**Links out**: Machine Detail, Commit Detail, Graph (test pre-filled), Profile, Compare (side A pre-selected), Regression Detail. + +**Regressions**: Below the samples table, a section showing regressions where the regression's commit matches the run's commit AND at least one indicator matches the run's machine. Each links to its regression detail page. ### 5. Commit Detail — `/v5/{ts}/commits/{value}` @@ -197,7 +202,9 @@ The "what happened at this commit?" page. Key investigation page for developers. - **Machine filter**: Text input for substring matching on machine names, filters the runs table. The summary updates to reflect filtered counts (e.g., "5 of 12 runs across 2 of 8 machines"). - **Runs table**: Columns: machine (link to Machine Detail), run UUID (link to Run Detail), start time - API: `GET commits/{value}`, `PATCH commits/{value}` (tag editing), `GET runs?commit={value}` -- **Links out**: Run Detail, Machine Detail +- **Links out**: Run Detail, Machine Detail, Regression Detail + +**Regressions at this commit**: Below the runs table, a section listing regressions where `commit` matches this commit's value. Each links to its regression detail page. ### 6. Graph (Time Series) — `/v5/graph?suite={ts}&machine={m}&metric={f}` @@ -228,7 +235,9 @@ The primary performance-over-time visualization. Replaces v4's graph page. This - **"No data to plot" annotation**: When no traces match the current filter/settings, the chart displays a Plotly annotation overlay ("No data to plot") centered on the chart area, preserving the x-axis scaffold so the user can see the commit range. - API: `POST query` with JSON body `{machine, metric, test, sort, limit, cursor}` (one fetch pipeline per machine, targeted to discovered tests via multi-value `test`), `GET tests?machine=...&metric=...&name_contains=...` (test name discovery), `GET machines/{name}/runs?sort=commit` (x-axis scaffold, per machine), `GET commits` (tags for baseline suggestions), `GET machines` (machine combobox), `GET test-suites/{ts}` (fields/metrics) - **URL state**: `?suite={ts}&machine={name}&machine={name2}&metric={name}&test_filter={text}&run_agg={fn}&sample_agg={fn}&baseline={suite}::{machine}::{commit}&baseline={suite2}::{machine2}::{commit2}` — the `machine` parameter is repeated for each selected machine; the `baseline` parameter is repeated for each baseline. Selected tests are NOT included in the URL (names can be very long); they are ephemeral page state preserved across SPA navigation but lost on page reload. -- **Links out**: Compare +- **Links out**: Compare, Regression Detail + +**Regression annotations**: A dropdown toggle "Regressions: Off | Active | All" (default Off) in the controls panel. When enabled, vertical dashed lines are drawn at the regression's commit position for regressions with indicators matching the current graph's test/machine/metric. Lines are color-coded by state (red=active, yellow=detected, gray=resolved). Hover shows the regression title and affected tests; click navigates to the regression detail page. ### 7. Compare — `/v5/compare?suite_a={ts}&...` @@ -325,21 +334,67 @@ Auth token is stored in `localStorage`, not in URL state (to avoid leaking crede - Only single-field commits are supported for the commit combobox. Multi-field commits use only the primary field. -**Links out**: Machine Detail, Run Detail, Graph (with machine pre-filled). +**Links out**: Machine Detail, Run Detail, Graph (with machine pre-filled), Regression Detail. + +**Add to regression**: A collapsible panel (button: "Add to regression" in the controls area). When expanded, offers: +- "Create new regression" — pre-fills commit, machines, tests, and metrics from the current comparison into a new regression +- "Add to existing" — a regression search combobox; adds the comparison's indicators to the selected regression +The panel collapses back to the button when done. + +### 8. Regression List — `/v5/{ts}/regressions` + +Main triage page for performance regressions. + +**Layout**: Filterable, sortable table of regressions. -### 8. Regression List — `/v5/{ts}/regressions` (STUB) +**Columns**: Title (linked to detail), State (badge), Commit (linked to commit detail), Machine count, Test count, Bug (external link). -Placeholder page displaying "Not implemented yet." Will be designed in a later deep dive. +**Filters** (control panel above table): +- State: multi-select chips (detected, active, not_to_be_fixed, fixed, false_positive) +- Machine: combobox with typeahead +- Test: combobox with typeahead +- Metric: dropdown +- Has commit: checkbox (surfaces regressions with unset commit) +- Free-text search on title -### 9. Regression Detail — `/v5/{ts}/regressions/{uuid}` (STUB) +**Actions**: +- "New regression" button → opens create form (inline or modal) with title, bug, state, commit fields. Indicators added after creation from the detail page. +- Row click → navigates to regression detail page. +- Delete: per-row action with confirmation prompt. -Placeholder page displaying "Not implemented yet." Will be designed in a later deep dive. +**Pagination**: Cursor-based, consistent with other list pages. -### 10. Field Change Triage — `/v5/{ts}/field-changes` (STUB) +Auth: requires `triage` scope for create/delete actions. -Placeholder page displaying "Not implemented yet." Will be designed in a later deep dive. +### 9. Regression Detail — `/v5/{ts}/regressions/{uuid}` -### 11. Admin — `/v5/admin` +Investigation and management page for a single regression. + +**Header section** (editable fields): +- Title: inline-editable text +- State: dropdown selector (detected, active, not_to_be_fixed, fixed, false_positive) +- Bug: URL input (opens in new tab when set) +- Commit: combobox with typeahead (nullable — the suspected introduction point). Linked to commit detail page when set. +- Notes: expandable textarea for investigation findings, A/B results, root cause analysis, etc. + +**Indicators table**: +- Columns: Machine, Test, Metric, remove button (×) +- Multi-select rows for batch remove +- "View on graph" link per indicator: opens Graph page pre-populated with the indicator's machine, test, metric, and the regression's commit as context + +**Add indicators panel** (below table): +- Three multi-select comboboxes with typeahead: Metric, Machine, Test +- Test list filtered by selected machines and metrics (only shows tests with data for the selected combination) +- Preview: "This will add N indicators" with expandable list +- "Add" button creates all (machine × test × metric) indicator combinations +- Duplicates (same machine+test+metric already on this regression) are silently ignored + +**Actions**: +- Delete regression button (with confirmation) + +Auth: requires `triage` scope for all modifications. + +### 10. Admin — `/v5/admin` Not test-suite specific. Served at `/v5/admin` (outside the `{ts}` namespace) with its own Flask route. The SPA shell is served without a testsuite; the admin page reads the list of available test suites from the HTML `data-testsuites` attribute. @@ -351,7 +406,7 @@ Not test-suite specific. Served at `/v5/admin` (outside the `{ts}` namespace) wi **Test Suites tab details**: - **Suite selector**: Dropdown to switch between test suites. Selecting a suite loads and displays its schema (metrics, commit fields, machine fields, run fields). -- **Delete suite**: A delete button per suite. Clicking it shows an inline confirmation panel explaining that deleting a suite permanently destroys all machines, runs, commits, samples, regressions, and field changes, and is irreversible. The user must type the exact suite name to confirm. Calls `DELETE /api/v5/test-suites/{name}?confirm=true`. Requires `manage` scope. +- **Delete suite**: A delete button per suite. Clicking it shows an inline confirmation panel explaining that deleting a suite permanently destroys all machines, runs, commits, samples, and regressions, and is irreversible. The user must type the exact suite name to confirm. Calls `DELETE /api/v5/test-suites/{name}?confirm=true`. Requires `manage` scope. **Create Suite tab**: - A name input and a JSON textarea where the user pastes the full suite definition (format_version, name, metrics, run_fields, machine_fields). The JSON format matches the `POST /api/v5/test-suites` API. On success, switches to the Schemas tab with the new suite auto-selected. Requires a token with `manage` scope. @@ -396,7 +451,6 @@ lnt/server/ui/v5/frontend/src/ │ ├── compare.ts Compare page module (auto-compare, caching, row toggling) │ ├── regression-list.ts │ ├── regression-detail.ts -│ ├── field-change-triage.ts │ └── admin.ts └── components/ ├── nav.ts Navigation bar @@ -436,10 +490,7 @@ outDir: resolve(__dirname, '../static/v5'), ## API Additions Needed -**None are blocking.** All v4 workflows can be served by the existing v5 API. - -One optional enhancement for performance: -- `GET /api/v5/{ts}/regressions?include=summary` — enriches list items with `indicator_count`, `earliest_commit`, `latest_commit` to avoid N+1 fetches on the regression list page. Without this, the frontend can fetch details lazily (regression lists are typically small). +**None are blocking.** All workflows can be served by the existing v5 API. The regression list endpoint returns machine/test counts directly (via indicator joins), so no additional summary endpoint is needed. ## Implementation Phases @@ -447,9 +498,9 @@ One optional enhancement for performance: |-------|-------|-----------------| | 1 | (none visible) | SPA shell, router, nav bar, Flask catch-all route, build config | | 2 | Test Suites (picker + tabs), Machine Detail, Run Detail, Commit Detail | Core browsing — data-table component, pagination, suite picker | -| 3 | Graph | Time-series chart component, combobox integration, aggregation controls, field change annotations | +| 3 | Graph | Time-series chart component, combobox integration, aggregation controls, regression annotations | | 4 | Compare | Absorb existing compare page into SPA as page module, add geomean summary | -| 5 | Regression List, Regression Detail, Field Change Triage (stubs) | Stub pages with "Not implemented yet" message | +| 5 | Regression List, Regression Detail | Full regression management pages, cross-page integration | | 6 | Admin, polish | API key management, error handling, loading states | ## Verification diff --git a/docs/v5-api-implementation-plan.md b/docs/v5-api-implementation-plan.md index dfae527bb..4b51874a6 100644 --- a/docs/v5-api-implementation-plan.md +++ b/docs/v5-api-implementation-plan.md @@ -480,83 +480,48 @@ GET /api/v5/{ts}/runs/{uuid}/tests/{test_name}/profile/functions/{fn_name} — **Endpoints:** ``` GET /api/v5/{ts}/regressions — List (cursor-paginated) -POST /api/v5/{ts}/regressions — Create from field changes -GET /api/v5/{ts}/regressions/{uuid} — Detail with indicators +POST /api/v5/{ts}/regressions — Create +GET /api/v5/{ts}/regressions/{uuid} — Detail (indicators embedded) PATCH /api/v5/{ts}/regressions/{uuid} — Update -DELETE /api/v5/{ts}/regressions/{uuid} — Delete -POST /api/v5/{ts}/regressions/{uuid}/merge — Merge -POST /api/v5/{ts}/regressions/{uuid}/split — Split -GET /api/v5/{ts}/regressions/{uuid}/indicators — List indicators -POST /api/v5/{ts}/regressions/{uuid}/indicators — Add indicator -DELETE /api/v5/{ts}/regressions/{uuid}/indicators/{fc_uuid} — Remove indicator +DELETE /api/v5/{ts}/regressions/{uuid} — Delete (cascades indicators) +POST /api/v5/{ts}/regressions/{uuid}/indicators — Add indicator(s) (batch) +DELETE /api/v5/{ts}/regressions/{uuid}/indicators — Remove indicator(s) (batch) ``` **Key design decisions:** -- Identified by **UUID** (NOT integer ID). Requires migration. +- Identified by **UUID** (NOT integer ID). - State mapping: API strings ↔ DB integers: `detected`↔0, `active`↔1, `not_to_be_fixed`↔2, `fixed`↔3, `false_positive`↔4 - State transitions unconstrained. +- Indicators are (machine, test, metric) tuples directly on the regression, + no FieldChange indirection. +- Regression has a nullable `commit` FK — the suspected introduction point. **Detail response** includes embedded indicators: ```json { "uuid": "...", "title": "...", "bug": "...", "state": "active", "notes": "...", + "commit": "abc123", "indicators": [ { - "field_change_uuid": "...", - "test": "...", "machine": "...", "metric": "...", - "old_value": 0.5, "new_value": 0.8, - "start_commit": "154000", "end_commit": "154331" + "uuid": "...", + "test": "...", "machine": "...", "metric": "..." } ] } ``` -**Merge**: target absorbs sources. Sources are deleted after their indicators -are moved to the target. Deduplicate indicators (don't link same field change twice). -Validate: cannot merge into self. -Request body uses UUIDs: `{"source_regression_uuids": ["...", "..."]}`. +**Filtering**: `state=` (multiple values), `machine=` (name, JOIN through +indicators→machines), `test=` (name, JOIN through indicators→tests), +`metric=`, `commit=`, `has_commit=`. -**Split**: move specified field changes to a new regression. Validate: cannot split ALL -indicators (would leave source empty). Request body uses UUIDs: -`{"field_change_uuids": ["...", "..."]}`. +Auth: read=GET, triage=POST/PATCH/DELETE and indicator management. -**Filtering**: `state=` (multiple values), `machine=` (name, requires JOIN through -indicators→field_changes→machines), `test=` (name, similar JOIN). +### 5.9 Field Changes — REMOVED -Auth: read=GET, triage=POST/PATCH/DELETE/merge/split/indicators. - -### 5.9 Field Changes - -**Endpoints:** -``` -GET /api/v5/{ts}/field-changes — List all field changes (cursor-paginated) -POST /api/v5/{ts}/field-changes — Create a field change -``` - -**Key design decisions:** -- Identified by **UUID**. -- Returns all FCs enriched with `regression_uuids` (list of regression UUIDs - the FC belongs to, empty if unassigned). Filter `?assigned=true/false` - controls inclusion. No ChangeIgnore in v5. -- Filters: `machine=`, `test=`, `metric=`, `assigned=` -- Auth: read=GET, submit=POST (create). - -**POST /field-changes (create):** -- Allows creating a field change programmatically (e.g., from external analysis tools) -- Request body fields (all resolved by name, not internal ID): - - `machine` (string, required) — machine name - - `test` (string, required) — test name - - `metric` (string, required) — metric name as defined in the test suite schema - - `old_value` (float, required) — previous value - - `new_value` (float, required) — new value - - `start_commit` (string, required) — commit identity string for the start of the change - - `end_commit` (string, required) — commit identity string for the end of the change -- Returns 404 if machine, test, start_commit, or end_commit cannot be resolved -- Returns 400 if metric is unknown -- Server generates a UUID for the new field change -- Returns 201 with the serialized field change on success +Field changes have been removed from the v5 API. Regressions directly +reference affected machines, tests, and metrics via RegressionIndicator. - Auth: `submit` scope required ### 5.10 Time Series diff --git a/docs/v5-db-implementation-plan.md b/docs/v5-db-implementation-plan.md index ad6adc06d..0a78f61de 100644 --- a/docs/v5-db-implementation-plan.md +++ b/docs/v5-db-implementation-plan.md @@ -316,50 +316,36 @@ Rename sort parameter value from `-start_time` to `-submitted_at` (update `MachineRunsQuerySchema` to match). Use new `serialize_run()`. Add `joinedload(ts.Run.commit_obj)` for serialization. -### 2.7 Endpoint: Field Changes (`field_changes.py`) +### 2.7 Endpoint: Field Changes — REMOVED -**Delete** ignore/un-ignore endpoints entirely (`POST .../ignore`, -`DELETE .../ignore`). No ChangeIgnore in v5. - -**`GET /field-changes`** — Remove ChangeIgnore LEFT JOIN. Replace -`resolve_metric()` call and `ts.FieldChange.field_id` filter with direct -string filter: `ts.FieldChange.field_name == metric_name` (no SampleField -lookup needed). Use new `serialize_fieldchange()`. - -**`POST /field-changes`** — Replace `start_order`/`end_order` with -`start_commit`/`end_commit` (strings). Look up commits via -`ts.get_commit()`. Use `ts.create_field_change(session, machine, test, -metric_name, start_commit, end_commit, old_value, new_value)` — pass all -values as arguments (replaces the v4 pattern of constructing then setting -attributes separately). Remove entire `run_uuid` resolution block (no run -FK on v5 FieldChange). +Field changes have been removed from v5. The `field_changes.py` endpoint +file should be deleted. Regressions directly reference affected machines, +tests, and metrics via RegressionIndicator. ### 2.8 Endpoint: Regressions (`regressions.py`) -**State mapping**: Update `STATE_TO_DB` to v5 integer values: +**State mapping**: `STATE_TO_DB` uses v5 integer values: `detected=0, active=1, not_to_be_fixed=2, fixed=3, false_positive=4`. -**`POST /regressions`** — Use `ts.create_regression(session, title, -[fc.id ...], bug=bug, state=state)`. - -**`PATCH /regressions/{uuid}`** — Use `ts.update_regression()`. +**New model**: Regressions have a nullable `commit_id` FK and `notes` TEXT +column. RegressionIndicator contains `(regression_id, machine_id, test_id, +metric)` directly — no FieldChange indirection. -**`DELETE /regressions/{uuid}`** — Use `ts.delete_regression()`. +**`POST /regressions`** — Create regression with optional commit, notes, and +inline indicators. Each indicator is `{machine, test, metric}` resolved by name. -**`POST .../merge`** — Delete source regressions after moving their indicators -to the target. Keep indicator-moving logic using `ts.RegressionIndicator` queries. +**`PATCH /regressions/{uuid}`** — Update title, bug, notes, state, commit. -**`POST .../split`** — Use `ts.create_regression(session, title, [], -...)` then move indicators. +**`DELETE /regressions/{uuid}`** — Cascades to indicators. -**`POST .../indicators`** — Use `ts.add_regression_indicator()`. Catch -`IntegrityError` → 409. +**`POST .../indicators`** — Batch add. Each indicator is `{machine, test, +metric}` resolved by name. Duplicates silently ignored. -**`DELETE .../indicators/{fc_uuid}`** — Use -`ts.remove_regression_indicator()`. If returns `False`, 404. +**`DELETE .../indicators`** — Batch remove by indicator UUIDs in body. -**Metric filter**: Remove `resolve_metric()` call entirely. Filter by +**Filtering**: `state=` (multiple values), `machine=`, `test=`, `metric=`, +`commit=`, `has_commit=`. Machine/test filters JOIN through indicators. `ts.FieldChange.field_name == metric_name` directly (no SampleField lookup, no `field_id`). diff --git a/docs/v5-submission-guide.md b/docs/v5-submission-guide.md index 018e522ac..32d29e642 100644 --- a/docs/v5-submission-guide.md +++ b/docs/v5-submission-guide.md @@ -195,5 +195,5 @@ All GET endpoints allow unauthenticated access by default. `commit_fields` in the submission are ignored. Use `PATCH /api/v5//commits/` to update. - **No regression auto-detection** — v5 does not auto-detect regressions. - Use `POST /api/v5//field-changes` to create them externally. + Use `POST /api/v5//regressions` to create them externally. - **Postgres required** — v5 instances only work with PostgreSQL. From f182b566f917e86bcca28cc2776e159aa553abc9 Mon Sep 17 00:00:00 2001 From: Louis Dionne Date: Wed, 15 Apr 2026 10:11:43 -0400 Subject: [PATCH 066/143] [DB] Implement redesigned regression model: drop FieldChange, new indicators Implement the DB layer changes for the regression model redesign: - Drop FieldChange table and all related CRUD methods - Add commit_id (nullable FK) and notes (TEXT) to Regression - Rewrite RegressionIndicator: uuid, machine_id, test_id, metric (replaces field_change_id FK) - Update REGRESSION_STATES: 5 states (detected, active, not_to_be_fixed, fixed, false_positive) replacing 7 - Apply _UNSET sentinel to all nullable fields in update_regression() - Add batch indicator add with silent duplicate handling - Update delete_commit() to guard on Regression.commit_id - Rewrite all DB-layer tests for new model API layer will be updated in a follow-up commit. Co-Authored-By: Claude Opus 4.6 (1M context) --- docs/v5-regression-db-implementation-plan.md | 1313 ++++++++++++++++++ lnt/server/db/v5/__init__.py | 244 ++-- lnt/server/db/v5/models.py | 103 +- tests/server/db/v5/test_crud.py | 446 ++++-- tests/server/db/v5/test_models.py | 238 +++- 5 files changed, 1942 insertions(+), 402 deletions(-) create mode 100644 docs/v5-regression-db-implementation-plan.md diff --git a/docs/v5-regression-db-implementation-plan.md b/docs/v5-regression-db-implementation-plan.md new file mode 100644 index 000000000..fa5cc856a --- /dev/null +++ b/docs/v5-regression-db-implementation-plan.md @@ -0,0 +1,1313 @@ +# v5 Regression DB Layer -- Implementation Plan + +This plan covers the DB layer changes needed to implement the redesigned +regression model described in `docs/design/v5-db.md` (sections D5, D8). + +**Goal**: Drop FieldChange, rewrite Regression and RegressionIndicator models +to match the design doc, update all CRUD methods and tests. + +## Files modified (complete list) + +| File | Change | +|------|--------| +| `lnt/server/db/v5/models.py` | Drop FieldChange model, update Regression + RegressionIndicator, update SuiteModels dataclass, update back-references | +| `lnt/server/db/v5/__init__.py` | Update REGRESSION_STATES (7 to 5), drop FieldChange CRUD, rewrite Regression + Indicator CRUD, update `delete_commit` | +| `tests/server/db/v5/test_models.py` | Drop FieldChange model tests, add new Regression/Indicator model tests | +| `tests/server/db/v5/test_crud.py` | Drop FieldChange CRUD tests, rewrite Regression + Indicator CRUD tests | +| `lnt/server/db/v5/schema.py` | No changes (FieldChange is not referenced) | + +**Out of scope** (API + UI, separate plan): The API endpoints in +`lnt/server/api/v5/endpoints/regressions.py`, `field_changes.py`, helpers, +and schemas all need rewriting too, but that is not covered here. + + +--- + +## 1. Model changes (`models.py`) + +File: `lnt/server/db/v5/models.py` + +### 1a. Update `SuiteModels` dataclass -- drop `FieldChange` attribute + +Lines 99-111. Remove the `FieldChange` field entirely. + +**Before** (line 108): +```python +@dataclass +class SuiteModels: + """Container for all SQLAlchemy model classes of a single test suite.""" + base: Any # declarative base + Commit: Any = None + Machine: Any = None + Run: Any = None + Test: Any = None + Sample: Any = None + FieldChange: Any = None # <-- DELETE this line + Regression: Any = None + RegressionIndicator: Any = None +``` + +**After**: +```python +@dataclass +class SuiteModels: + """Container for all SQLAlchemy model classes of a single test suite.""" + base: Any # declarative base + Commit: Any = None + Machine: Any = None + Run: Any = None + Test: Any = None + Sample: Any = None + Regression: Any = None + RegressionIndicator: Any = None +``` + +### 1b. Delete the entire FieldChange model block + +Delete lines 262-312 (the `# FieldChange` section, including the `fc_attrs` +dict, `FieldChange = type(...)`, and the compound index on +`FieldChange.machine_id, FieldChange.test_id, FieldChange.field_name`). + +This removes: +- The `{prefix}_FieldChange` table definition +- All its columns: `id`, `uuid`, `test_id` (FK), `machine_id` (FK), + `field_name`, `start_commit_id` (FK), `end_commit_id` (FK), + `old_value`, `new_value` +- Relations: `test`, `machine`, `start_commit`, `end_commit` +- The compound index `ix_{prefix}_FieldChange_machine_test_field` + +### 1c. Update the Regression model -- add `commit_id` FK and `notes` column + +Lines 316-328. The current Regression model has: `id`, `uuid`, `title`, `bug`, +`state`. The design doc adds two columns: + +- `commit_id`: Integer FK -> Commit, nullable, indexed +- `notes`: Text, nullable + +**Before** (lines 317-328): +```python + reg_attrs: dict[str, Any] = { + "__tablename__": f"{prefix}_Regression", + "id": Column("id", Integer, primary_key=True), + "uuid": Column( + "uuid", String(36), unique=True, nullable=False, index=True, + default=lambda: str(uuid_module.uuid4()), + ), + "title": Column("title", String(256), nullable=True), + "bug": Column("bug", String(256), nullable=True), + "state": Column("state", Integer, nullable=False, index=True), + } + Regression = type("Regression", (base,), reg_attrs) +``` + +**After**: +```python + reg_attrs: dict[str, Any] = { + "__tablename__": f"{prefix}_Regression", + "id": Column("id", Integer, primary_key=True), + "uuid": Column( + "uuid", String(36), unique=True, nullable=False, index=True, + default=lambda: str(uuid_module.uuid4()), + ), + "title": Column("title", String(256), nullable=True), + "bug": Column("bug", String(256), nullable=True), + "notes": Column("notes", Text, nullable=True), + "state": Column("state", Integer, nullable=False, index=True), + "commit_id": Column( + "commit_id", Integer, + ForeignKey(f"{prefix}_Commit.id"), + nullable=True, index=True, + ), + "commit_obj": relation( + "Commit", foreign_keys=f"{prefix}_Regression.c.commit_id", + ), + } + Regression = type("Regression", (base,), reg_attrs) +``` + +Key design decisions for `commit_id`: +- **No `ondelete="CASCADE"`**. The design doc (D5, Commit section) says + "Commits referenced by a Regression's commit_id cannot be deleted (the API + returns 409)." So we use the default `RESTRICT` behavior -- the DB itself + prevents deletion of a commit that is referenced by a regression. The API + layer catches the IntegrityError and returns 409. +- The relation is named `commit_obj` (same pattern as `Run.commit_obj`) to + avoid collision with Python builtins. + +### 1d. Rewrite the RegressionIndicator model + +Lines 333-359. Completely replace. The current model has `field_change_id` FK +and a unique constraint on `(regression_id, field_change_id)`. The new model +replaces this with `uuid`, `machine_id` FK, `test_id` FK, `metric` string, +and a unique constraint on `(regression_id, machine_id, test_id, metric)`. + +**Before** (lines 333-359): +```python + ri_attrs: dict[str, Any] = { + "__tablename__": f"{prefix}_RegressionIndicator", + "id": Column("id", Integer, primary_key=True), + "regression_id": Column( + "regression_id", Integer, + ForeignKey(f"{prefix}_Regression.id", ondelete="CASCADE"), + nullable=False, index=True, + ), + "field_change_id": Column( + "field_change_id", Integer, + ForeignKey(f"{prefix}_FieldChange.id", ondelete="CASCADE"), + nullable=False, index=True, + ), + "__table_args__": ( + UniqueConstraint("regression_id", "field_change_id", + name=f"uq_{prefix}_ri_regression_fieldchange"), + ), + "regression": relation( + "Regression", + foreign_keys=f"{prefix}_RegressionIndicator.c.regression_id", + ), + "field_change": relation( + "FieldChange", + foreign_keys=f"{prefix}_RegressionIndicator.c.field_change_id", + ), + } + RegressionIndicator = type("RegressionIndicator", (base,), ri_attrs) +``` + +**After**: +```python + ri_attrs: dict[str, Any] = { + "__tablename__": f"{prefix}_RegressionIndicator", + "id": Column("id", Integer, primary_key=True), + "uuid": Column( + "uuid", String(36), unique=True, nullable=False, index=True, + default=lambda: str(uuid_module.uuid4()), + ), + "regression_id": Column( + "regression_id", Integer, + ForeignKey(f"{prefix}_Regression.id", ondelete="CASCADE"), + nullable=False, index=True, + ), + "machine_id": Column( + "machine_id", Integer, + ForeignKey(f"{prefix}_Machine.id"), + nullable=False, index=True, + ), + "test_id": Column( + "test_id", Integer, + ForeignKey(f"{prefix}_Test.id"), + nullable=False, index=True, + ), + "metric": Column("metric", String(256), nullable=False), + "__table_args__": ( + UniqueConstraint( + "regression_id", "machine_id", "test_id", "metric", + name=f"uq_{prefix}_ri_reg_machine_test_metric", + ), + ), + "regression": relation( + "Regression", + foreign_keys=f"{prefix}_RegressionIndicator.c.regression_id", + ), + "machine": relation( + "Machine", + foreign_keys=f"{prefix}_RegressionIndicator.c.machine_id", + ), + "test": relation( + "Test", + foreign_keys=f"{prefix}_RegressionIndicator.c.test_id", + ), + } + RegressionIndicator = type("RegressionIndicator", (base,), ri_attrs) +``` + +Key decisions for `machine_id` and `test_id` FKs on RegressionIndicator: +- **No `ondelete="CASCADE"`** on `machine_id` and `test_id`. We do not want + deleting a machine or test to silently wipe regression indicators. If a + machine/test is deleted while indicators reference it, the DB should block + the delete (default RESTRICT). This is a safety choice -- regressions are + triage artifacts and should not vanish when the underlying entities change. +- `regression_id` keeps `ondelete="CASCADE"` -- deleting a regression should + always cascade to its indicators. + +### 1e. Update back-references + +Lines 363-405. Three changes: + +1. **Delete** the `FieldChange.regression_indicators` back-reference (lines + 392-398). This block no longer exists because FieldChange is gone: + ```python + # DELETE this entire block: + FieldChange.regression_indicators = relation( + RegressionIndicator, + foreign_keys=[RegressionIndicator.field_change_id], + back_populates="field_change", + cascade="all, delete-orphan", + passive_deletes=True, + ) + ``` + +2. **Keep** the `Regression.indicators` back-reference (lines 399-405) + unchanged. It still cascades via `regression_id`. + +3. **No new back-references needed** on Machine or Test for indicators. + The `machine` and `test` relations on RegressionIndicator are forward-only + lookups; we do not need `Machine.regression_indicators` or + `Test.regression_indicators` collections. + +### 1f. Update the `return SuiteModels(...)` call + +Lines 407-417. Remove `FieldChange=FieldChange` from the constructor. + +**Before** (lines 407-417): +```python + return SuiteModels( + base=base, + Commit=Commit, + Machine=Machine, + Run=Run, + Test=Test, + Sample=Sample, + FieldChange=FieldChange, + Regression=Regression, + RegressionIndicator=RegressionIndicator, + ) +``` + +**After**: +```python + return SuiteModels( + base=base, + Commit=Commit, + Machine=Machine, + Run=Run, + Test=Test, + Sample=Sample, + Regression=Regression, + RegressionIndicator=RegressionIndicator, + ) +``` + +### 1g. Summary of table count change + +Before: 8 per-suite tables (Commit, Machine, Run, Test, Sample, FieldChange, +Regression, RegressionIndicator). +After: 7 per-suite tables (FieldChange dropped). + + +--- + +## 2. State machine changes (`__init__.py`) + +File: `lnt/server/db/v5/__init__.py`, lines 34-43. + +The current `REGRESSION_STATES` has 7 entries (0-6): +```python +REGRESSION_STATES = { + 0: "detected", + 1: "staged", + 2: "active", + 3: "not_to_be_fixed", + 4: "ignored", + 5: "fixed", + 6: "detected_fixed", +} +``` + +The design doc specifies 5 states (0-4): +```python +REGRESSION_STATES = { + 0: "detected", + 1: "active", + 2: "not_to_be_fixed", + 3: "fixed", + 4: "false_positive", +} +``` + +Replace the entire dict. `VALID_REGRESSION_STATES` (line 43) derives from +this dict and needs no separate change. + +**Impact**: The validation function `_validate_regression_state()` (line +260-266) uses `VALID_REGRESSION_STATES` and needs no code change -- it +automatically reflects the new dict. However, any existing test data or API +code using old state names (`staged`, `ignored`, `detected_fixed`) or old +numeric values (5, 6) will break. This is intentional: v5 is a clean break. + + +--- + +## 3. CRUD method changes (`__init__.py`) + +File: `lnt/server/db/v5/__init__.py` + +### 3a. Drop the `self.FieldChange` attribute from `V5TestSuiteDB.__init__` + +Line 288. Delete `self.FieldChange = models.FieldChange`. + +### 3b. Update `delete_commit()` -- remove FieldChange guard + +Lines 419-452. The current implementation checks for FieldChanges referencing +the commit (via `start_commit_id`/`end_commit_id`) and blocks deletion. Since +FieldChange is dropped, this guard must be replaced. + +The design doc says: "Commits referenced by a Regression's commit_id cannot +be deleted (the API returns 409)." The DB-level FK constraint (RESTRICT) on +`Regression.commit_id -> Commit.id` will prevent the deletion at the database +level. The CRUD method should catch this. + +**Before** (lines 419-452): +```python + def delete_commit( + self, + session: sqlalchemy.orm.Session, + commit_id: int, + ) -> None: + """Delete a commit by ID (cascades to runs and samples). + + Raises ``ValueError`` if any FieldChanges reference this commit + (via ``start_commit_id`` or ``end_commit_id``). Those must be + deleted first. + """ + commit = session.query(self.Commit).get(commit_id) + if commit is None: + return + + fc_count = ( + session.query(self.FieldChange) + .filter( + or_( + self.FieldChange.start_commit_id == commit_id, + self.FieldChange.end_commit_id == commit_id, + ) + ) + .count() + ) + if fc_count > 0: + raise ValueError( + f"Cannot delete commit {commit_id}: " + f"{fc_count} FieldChange(s) reference it; " + f"delete them first" + ) + + session.delete(commit) + session.flush() +``` + +**After**: +```python + def delete_commit( + self, + session: sqlalchemy.orm.Session, + commit_id: int, + ) -> None: + """Delete a commit by ID (cascades to runs and samples). + + Raises ``ValueError`` if any Regressions reference this commit + (via ``commit_id``). Those must be updated first. + """ + commit = session.query(self.Commit).get(commit_id) + if commit is None: + return + + reg_count = ( + session.query(self.Regression) + .filter(self.Regression.commit_id == commit_id) + .count() + ) + if reg_count > 0: + raise ValueError( + f"Cannot delete commit {commit_id}: " + f"{reg_count} Regression(s) reference it; " + f"clear their commit_id first" + ) + + session.delete(commit) + session.flush() +``` + +Also remove the `from sqlalchemy import or_` import if `delete_commit` was its +only consumer. Check: `or_` is also used by `list_commits()` (line 403) and +`list_machines()` (line 549), so the import stays. + +### 3c. Drop all FieldChange CRUD methods + +Delete the entire "FieldChanges (CRUD only)" section, lines 922-994: +- `create_field_change()` (lines 926-949) +- `get_field_change()` (lines 951-964) +- `list_field_changes()` (lines 966-983) +- `delete_field_change()` (lines 985-994) + +### 3d. Rewrite `create_regression()` + +Lines 996-1023. The current signature takes `field_change_ids`. The new +signature takes `indicators` (list of dicts) plus optional `notes` and +`commit` parameters. + +**Before**: +```python + def create_regression( + self, + session: sqlalchemy.orm.Session, + title: str, + field_change_ids: list[int], + *, + bug: str | None = None, + state: int = 0, + ): + """Create a Regression with the given FieldChange indicators.""" + _validate_regression_state(state) + reg = self.Regression() + reg.uuid = str(uuid_module.uuid4()) + reg.title = title + reg.bug = bug + reg.state = state + session.add(reg) + session.flush() + + indicators = [] + for fc_id in field_change_ids: + ri = self.RegressionIndicator() + ri.regression_id = reg.id + ri.field_change_id = fc_id + indicators.append(ri) + session.add_all(indicators) + session.flush() + return reg +``` + +**After**: +```python + def create_regression( + self, + session: sqlalchemy.orm.Session, + title: str, + indicators: list[dict[str, Any]], + *, + bug: str | None = None, + notes: str | None = None, + commit: Any | None = None, + state: int = 0, + ): + """Create a Regression with the given indicators. + + Each dict in *indicators* must have keys ``machine_id`` (int), + ``test_id`` (int), and ``metric`` (str). + + *commit* is an optional Commit object whose id is stored on the + Regression (nullable FK). + """ + _validate_regression_state(state) + reg = self.Regression() + reg.uuid = str(uuid_module.uuid4()) + reg.title = title + reg.bug = bug + reg.notes = notes + reg.state = state + reg.commit_id = commit.id if commit is not None else None + session.add(reg) + session.flush() + + ri_objects = [] + for ind in indicators: + ri = self.RegressionIndicator() + ri.uuid = str(uuid_module.uuid4()) + ri.regression_id = reg.id + ri.machine_id = ind["machine_id"] + ri.test_id = ind["test_id"] + ri.metric = ind["metric"] + ri_objects.append(ri) + session.add_all(ri_objects) + session.flush() + return reg +``` + +### 3e. Rewrite `update_regression()` + +Lines 1040-1058. Add `notes` and `commit` parameters. + +**Before**: +```python + def update_regression( + self, + session: sqlalchemy.orm.Session, + regression, + *, + title: str | None = None, + bug: str | None = None, + state: int | None = None, + ): + """Update mutable fields on a Regression.""" + if title is not None: + regression.title = title + if bug is not None: + regression.bug = bug + if state is not None: + _validate_regression_state(state) + regression.state = state + session.flush() + return regression +``` + +**After**: +```python + _UNSET = object() + + def update_regression( + self, + session: sqlalchemy.orm.Session, + regression, + *, + title: Any = _UNSET, + bug: Any = _UNSET, + notes: Any = _UNSET, + commit: Any = _UNSET, + state: int | None = None, + ): + """Update mutable fields on a Regression. + + For *title*, *bug*, *notes*, and *commit*: pass a value to set, + ``None`` to clear, or omit (default ``_UNSET``) to leave unchanged. + *state* uses ``None`` as "leave unchanged" (state cannot be null). + """ + if title is not self._UNSET: + regression.title = title + if bug is not self._UNSET: + regression.bug = bug + if notes is not self._UNSET: + regression.notes = notes + if commit is not self._UNSET: + regression.commit_id = commit.id if commit is not None else None + if state is not None: + _validate_regression_state(state) + regression.state = state + session.flush() + return regression +``` + +The `_UNSET` sentinel distinguishes "caller didn't pass the argument" from +"caller explicitly passed ``None`` to clear the field." This is applied +consistently to all nullable string/text fields (`title`, `bug`, `notes`) +and the nullable FK (`commit`). `state` uses `None` as "leave unchanged" +since state is not nullable and can never be cleared. + +Note: `_UNSET` is defined as a class attribute on `V5TestSuiteDB` (not a +module-level global) to keep the namespace clean. Place it just before +`update_regression`. + +### 3f. Verify `delete_regression()` -- no changes needed + +Lines 1073-1081. The cascade on `RegressionIndicator.regression_id` (with +`ondelete="CASCADE"` and SQLAlchemy's `cascade="all, delete-orphan"`) handles +cleanup. No code changes needed here. + +### 3g. Rewrite `add_regression_indicator()` + +Lines 1084-1100. Replace `field_change` parameter with `machine_id`, `test_id`, +`metric`. + +**Before**: +```python + def add_regression_indicator( + self, + session: sqlalchemy.orm.Session, + regression, + field_change, + ): + """Add a FieldChange as an indicator on a Regression. + + Returns the created RegressionIndicator. Raises + ``sqlalchemy.exc.IntegrityError`` if the pair already exists. + """ + ri = self.RegressionIndicator() + ri.regression_id = regression.id + ri.field_change_id = field_change.id + session.add(ri) + session.flush() + return ri +``` + +**After** (single-indicator method): +```python + def add_regression_indicator( + self, + session: sqlalchemy.orm.Session, + regression, + machine_id: int, + test_id: int, + metric: str, + ): + """Add an indicator to a Regression. + + Returns the created RegressionIndicator. Raises + ``sqlalchemy.exc.IntegrityError`` if the (regression, machine, + test, metric) combination already exists. + """ + ri = self.RegressionIndicator() + ri.uuid = str(uuid_module.uuid4()) + ri.regression_id = regression.id + ri.machine_id = machine_id + ri.test_id = test_id + ri.metric = metric + session.add(ri) + session.flush() + return ri +``` + +**Add batch method** for the API's "silently ignore duplicates" requirement: +```python + def add_regression_indicators_batch( + self, + session: sqlalchemy.orm.Session, + regression, + indicators: list[dict[str, Any]], + ) -> list: + """Add multiple indicators to a Regression, silently ignoring duplicates. + + Each dict must have keys ``machine_id``, ``test_id``, ``metric``. + Returns the list of newly created RegressionIndicator objects + (excludes duplicates that were skipped). + + Note: the check-then-insert pattern has a TOCTOU window under + concurrent access. The unique constraint catches this at the DB + level; the API layer is expected to serialize regression updates. + """ + created = [] + for ind in indicators: + existing = ( + session.query(self.RegressionIndicator) + .filter_by( + regression_id=regression.id, + machine_id=ind["machine_id"], + test_id=ind["test_id"], + metric=ind["metric"], + ) + .first() + ) + if existing is not None: + continue + ri = self.RegressionIndicator() + ri.uuid = str(uuid_module.uuid4()) + ri.regression_id = regression.id + ri.machine_id = ind["machine_id"] + ri.test_id = ind["test_id"] + ri.metric = ind["metric"] + session.add(ri) + created.append(ri) + session.flush() + return created +``` + +### 3h. Rewrite `remove_regression_indicator()` + +Lines 1102-1122. Replace `field_change_id` parameter with `machine_id`, +`test_id`, `metric`. Alternatively, accept `indicator_id` or `indicator_uuid` +for simplicity. + +Two options: + +**Option A** -- lookup by (regression_id, machine_id, test_id, metric): +```python + def remove_regression_indicator( + self, + session: sqlalchemy.orm.Session, + regression_id: int, + machine_id: int, + test_id: int, + metric: str, + ) -> bool: + """Remove a single indicator from a regression. + + Returns True if an indicator was removed, False if none matched. + """ + count = ( + session.query(self.RegressionIndicator) + .filter( + self.RegressionIndicator.regression_id == regression_id, + self.RegressionIndicator.machine_id == machine_id, + self.RegressionIndicator.test_id == test_id, + self.RegressionIndicator.metric == metric, + ) + .delete() + ) + if count: + session.flush() + return count > 0 +``` + +**Option B** -- lookup by uuid (simpler, mirrors the API pattern where +indicators have their own uuid): +```python + def remove_regression_indicator( + self, + session: sqlalchemy.orm.Session, + regression_id: int, + indicator_uuid: str, + ) -> bool: + """Remove an indicator from a regression by UUID. + + Returns True if an indicator was removed, False if none matched. + """ + count = ( + session.query(self.RegressionIndicator) + .filter( + self.RegressionIndicator.regression_id == regression_id, + self.RegressionIndicator.uuid == indicator_uuid, + ) + .delete() + ) + if count: + session.flush() + return count > 0 +``` + +**Recommendation**: Implement Option B (by uuid). The indicator uuid is the +natural identifier exposed by the API. Also add a `get_regression_indicator()` +method for lookup by uuid: + +```python + def get_regression_indicator( + self, + session: sqlalchemy.orm.Session, + *, + id: int | None = None, + uuid: str | None = None, + ): + """Fetch a single RegressionIndicator by id or uuid.""" + q = session.query(self.RegressionIndicator) + if id is not None: + return q.filter(self.RegressionIndicator.id == id).first() + if uuid is not None: + return q.filter(self.RegressionIndicator.uuid == uuid).first() + raise ValueError("must specify id or uuid") +``` + + +--- + +## 4. Test changes + +### 4a. `tests/server/db/v5/test_models.py` + +**Drop FieldChange test class** -- `TestFieldChangeAndRegression` (lines +450-542). This entire class tests FieldChange creation, the unique constraint +on `(regression_id, field_change_id)`, and the regression indicator model +bound to FieldChange. All of this is obsolete. + +**Update `TestModelCreation.test_all_tables_created`** (lines 95-104): +Change expected table count from 8 to 7, remove `"t_FieldChange"` from the +expected set: + +```python + def test_all_tables_created(self): + """All 7 per-suite tables should exist.""" + insp = sqlalchemy.inspect(self.engine) + tables = set(insp.get_table_names()) + expected = { + "t_Commit", "t_Machine", "t_Run", "t_Test", + "t_Sample", "t_Regression", + "t_RegressionIndicator", + } + self.assertTrue(expected.issubset(tables), f"Missing: {expected - tables}") +``` + +**Add new test class `TestRegressionAndIndicatorModels`** replacing the dropped +class. Tests to include: + +1. **Create a Regression with `commit_id` and `notes`**: Create a Commit, + create a Regression referencing it, verify `commit_id` and `notes` are + persisted. +2. **Regression `commit_id` nullable**: Create a Regression without a + `commit_id`, verify it persists with `NULL`. +3. **RegressionIndicator has uuid**: Create an indicator, verify uuid is + populated. +4. **RegressionIndicator unique constraint on (regression_id, machine_id, + test_id, metric)**: Insert a duplicate and assert IntegrityError. +5. **RegressionIndicator unique constraint allows same (machine, test, metric) + on different regressions**: Create two regressions with the same indicator + triple; should succeed. +6. **Cascading delete: deleting Regression cascades to indicators**: Create a + regression with indicators, delete regression, verify indicators are gone. +7. **Commit referenced by Regression cannot be deleted**: Create regression + with `commit_id` set, attempt to delete the commit, expect DB-level FK + violation (IntegrityError). + +### 4b. `tests/server/db/v5/test_crud.py` + +**Drop the following test classes entirely:** +- `TestFieldChangeCRUD` (lines 157-255) -- tests FieldChange creation, + regression creation via `field_change_ids`, all FieldChange-based workflow +- `TestDeleteCommit.test_delete_commit_blocked_by_field_changes` (lines + 310-329) -- tests the FieldChange guard +- `TestDeleteFieldChange` (lines 500-550) -- tests FieldChange deletion + and cascade to indicators +- `TestRegressionIndicatorManagement` (lines 553-616) -- tests indicator + add/remove via FieldChange objects + +**Update `TestDeleteCommit`:** +- Update class docstring from "blocked by FieldChanges" to "blocked by + Regressions". +- Keep `test_delete_commit_cascades_to_runs_and_samples` (lines 278-308) + unchanged. +- Replace `test_delete_commit_blocked_by_field_changes` with + `test_delete_commit_blocked_by_regression_commit_ref`: Create a regression + with `commit_id` pointing to a commit. Attempt to delete that commit. + Assert `ValueError` is raised. +- Keep `test_delete_nonexistent_commit` (lines 332-335) unchanged. + +**Update `TestRegressionStateValidation`:** +- `test_all_valid_states_accepted` (lines 637-644) must reflect the new 5 + states (0-4). The test iterates `VALID_REGRESSION_STATES` so it adapts + automatically, but verify that `create_regression` is called with the new + indicator-list format (empty list `[]` becomes empty indicator dicts `[]`). +- `test_create_with_invalid_state` (line 622-624) -- update + `create_regression` call to use new signature: + `self.tsdb.create_regression(session, "bad state", [], state=99)` + The `[]` already matches the new format (list of dicts), so no actual + change needed. +- `test_update_with_invalid_state` (lines 628-634) -- same: update + `create_regression` call if needed. + +**Add new test class `TestRegressionCRUD`** (replacing parts of +`TestFieldChangeCRUD.test_regression_crud`): + +```python +class TestRegressionCRUD(_CRUDTestBase): + + def test_create_regression_with_indicators(self): + """Create a regression with machine/test/metric indicators.""" + session = self.Session() + machine = self.tsdb.get_or_create_machine(session, "reg-m") + test = self.tsdb.get_or_create_test(session, "reg-test") + session.flush() + + reg = self.tsdb.create_regression( + session, "Perf regression", + [{"machine_id": machine.id, "test_id": test.id, + "metric": "execution_time"}], + bug="BUG-123", state=0) + session.commit() + + self.assertIsNotNone(reg.uuid) + self.assertEqual(reg.title, "Perf regression") + self.assertEqual(reg.bug, "BUG-123") + self.assertEqual(reg.state, 0) + self.assertIsNone(reg.notes) + self.assertIsNone(reg.commit_id) + + # Verify indicator was created + indicators = ( + session.query(self.tsdb.RegressionIndicator) + .filter_by(regression_id=reg.id) + .all() + ) + self.assertEqual(len(indicators), 1) + self.assertEqual(indicators[0].machine_id, machine.id) + self.assertEqual(indicators[0].test_id, test.id) + self.assertEqual(indicators[0].metric, "execution_time") + self.assertIsNotNone(indicators[0].uuid) + session.close() + + def test_create_regression_with_notes_and_commit(self): + session = self.Session() + commit = self.tsdb.get_or_create_commit(session, "reg-commit-1") + session.flush() + + reg = self.tsdb.create_regression( + session, "Noted regression", [], + notes="Caused by vectorizer change", + commit=commit, + state=1) + session.commit() + + self.assertEqual(reg.notes, "Caused by vectorizer change") + self.assertEqual(reg.commit_id, commit.id) + session.close() + + def test_create_regression_with_empty_indicators(self): + session = self.Session() + reg = self.tsdb.create_regression( + session, "Empty regression", [], state=0) + session.commit() + self.assertIsNotNone(reg.id) + # Verify no indicators were created + indicators = ( + session.query(self.tsdb.RegressionIndicator) + .filter_by(regression_id=reg.id) + .all() + ) + self.assertEqual(len(indicators), 0) + session.close() + + def test_update_regression_notes(self): + session = self.Session() + reg = self.tsdb.create_regression( + session, "title", [], state=0) + session.commit() + + self.tsdb.update_regression( + session, reg, notes="New notes") + session.commit() + + fetched = self.tsdb.get_regression(session, id=reg.id) + self.assertEqual(fetched.notes, "New notes") + session.close() + + def test_update_regression_commit(self): + session = self.Session() + commit = self.tsdb.get_or_create_commit(session, "upd-reg-c") + reg = self.tsdb.create_regression( + session, "title", [], state=0) + session.commit() + + self.tsdb.update_regression( + session, reg, commit=commit) + session.commit() + self.assertEqual(reg.commit_id, commit.id) + + # Clear commit + self.tsdb.update_regression( + session, reg, commit=None) + session.commit() + self.assertIsNone(reg.commit_id) + session.close() + + def test_update_regression_state_and_title(self): + session = self.Session() + reg = self.tsdb.create_regression( + session, "original", [], state=0) + session.commit() + + self.tsdb.update_regression( + session, reg, title="Updated", state=1) + session.commit() + + fetched = self.tsdb.get_regression(session, uuid=reg.uuid) + self.assertEqual(fetched.title, "Updated") + self.assertEqual(fetched.state, 1) + session.close() + + def test_delete_regression_cascades_to_indicators(self): + session = self.Session() + machine = self.tsdb.get_or_create_machine(session, "del-reg-m") + test = self.tsdb.get_or_create_test(session, "del-reg-test") + session.flush() + + reg = self.tsdb.create_regression( + session, "to delete", + [{"machine_id": machine.id, "test_id": test.id, + "metric": "execution_time"}], + state=0) + session.commit() + reg_id = reg.id + + self.tsdb.delete_regression(session, reg_id) + session.commit() + + self.assertIsNone(self.tsdb.get_regression(session, id=reg_id)) + indicators = ( + session.query(self.tsdb.RegressionIndicator) + .filter_by(regression_id=reg_id) + .all() + ) + self.assertEqual(len(indicators), 0) + session.close() + + def test_list_regressions_by_state(self): + session = self.Session() + self.tsdb.create_regression( + session, "active-one", [], state=1) + self.tsdb.create_regression( + session, "detected-one", [], state=0) + session.commit() + + active = self.tsdb.list_regressions(session, state=1) + self.assertGreater(len(active), 0) + self.assertTrue( + all(r.state == 1 for r in active)) + session.close() + + def test_update_regression_clear_notes(self): + """Verify _UNSET pattern allows clearing notes to None.""" + session = self.Session() + reg = self.tsdb.create_regression( + session, "title", [], notes="some notes", state=0) + session.commit() + self.assertEqual(reg.notes, "some notes") + + self.tsdb.update_regression(session, reg, notes=None) + session.commit() + self.assertIsNone(reg.notes) + session.close() + + def test_update_regression_clear_title(self): + """Verify _UNSET pattern allows clearing title to None.""" + session = self.Session() + reg = self.tsdb.create_regression( + session, "title", [], state=0) + session.commit() + + self.tsdb.update_regression(session, reg, title=None) + session.commit() + self.assertIsNone(reg.title) + session.close() + + def test_update_regression_clear_bug(self): + """Verify _UNSET pattern allows clearing bug to None.""" + session = self.Session() + reg = self.tsdb.create_regression( + session, "title", [], bug="BUG-1", state=0) + session.commit() + + self.tsdb.update_regression(session, reg, bug=None) + session.commit() + self.assertIsNone(reg.bug) + session.close() + + def test_old_state_values_rejected(self): + """States 5 and 6 (old staged/detected_fixed) must be rejected.""" + session = self.Session() + with self.assertRaises(ValueError): + self.tsdb.create_regression( + session, "old state", [], state=5) + with self.assertRaises(ValueError): + self.tsdb.create_regression( + session, "old state", [], state=6) + session.close() +``` + +**Add new test class `TestRegressionIndicatorManagement`** (replacing the +dropped class): + +```python +class TestRegressionIndicatorManagement(_CRUDTestBase): + + def test_add_regression_indicator(self): + session = self.Session() + machine = self.tsdb.get_or_create_machine(session, "ri-add-m") + test = self.tsdb.get_or_create_test(session, "ri-add-test") + reg = self.tsdb.create_regression( + session, "add-ind", [], state=0) + session.flush() + + ri = self.tsdb.add_regression_indicator( + session, reg, machine.id, test.id, "execution_time") + session.commit() + + self.assertIsNotNone(ri.id) + self.assertIsNotNone(ri.uuid) + self.assertEqual(ri.machine_id, machine.id) + self.assertEqual(ri.test_id, test.id) + self.assertEqual(ri.metric, "execution_time") + session.close() + + def test_add_duplicate_indicator_rejected(self): + session = self.Session() + machine = self.tsdb.get_or_create_machine(session, "ri-dup-m") + test = self.tsdb.get_or_create_test(session, "ri-dup-test") + reg = self.tsdb.create_regression( + session, "dup-ind", + [{"machine_id": machine.id, "test_id": test.id, + "metric": "execution_time"}], + state=0) + session.commit() + + with self.assertRaises(sqlalchemy.exc.IntegrityError): + self.tsdb.add_regression_indicator( + session, reg, machine.id, test.id, "execution_time") + session.rollback() + session.close() + + def test_same_triple_on_different_regressions_ok(self): + session = self.Session() + machine = self.tsdb.get_or_create_machine(session, "ri-multi-m") + test = self.tsdb.get_or_create_test(session, "ri-multi-test") + reg1 = self.tsdb.create_regression( + session, "reg1", [], state=0) + reg2 = self.tsdb.create_regression( + session, "reg2", [], state=0) + session.flush() + + ri1 = self.tsdb.add_regression_indicator( + session, reg1, machine.id, test.id, "execution_time") + ri2 = self.tsdb.add_regression_indicator( + session, reg2, machine.id, test.id, "execution_time") + session.commit() + + self.assertIsNotNone(ri1.id) + self.assertIsNotNone(ri2.id) + session.close() + + def test_remove_regression_indicator_by_uuid(self): + session = self.Session() + machine = self.tsdb.get_or_create_machine(session, "ri-rem-m") + test = self.tsdb.get_or_create_test(session, "ri-rem-test") + reg = self.tsdb.create_regression( + session, "rem-ind", + [{"machine_id": machine.id, "test_id": test.id, + "metric": "execution_time"}], + state=0) + session.commit() + + indicator = ( + session.query(self.tsdb.RegressionIndicator) + .filter_by(regression_id=reg.id) + .first() + ) + removed = self.tsdb.remove_regression_indicator( + session, reg.id, indicator.uuid) + session.commit() + self.assertTrue(removed) + + remaining = ( + session.query(self.tsdb.RegressionIndicator) + .filter_by(regression_id=reg.id) + .all() + ) + self.assertEqual(len(remaining), 0) + session.close() + + def test_remove_nonexistent_indicator(self): + session = self.Session() + removed = self.tsdb.remove_regression_indicator( + session, 999, "nonexistent-uuid") + self.assertFalse(removed) + session.close() + + def test_remove_indicator_wrong_regression(self): + """Indicator exists but belongs to a different regression.""" + session = self.Session() + machine = self.tsdb.get_or_create_machine(session, "ri-wrong-m") + test = self.tsdb.get_or_create_test(session, "ri-wrong-test") + reg1 = self.tsdb.create_regression( + session, "reg1", + [{"machine_id": machine.id, "test_id": test.id, + "metric": "execution_time"}], + state=0) + reg2 = self.tsdb.create_regression( + session, "reg2", [], state=0) + session.commit() + + indicator = ( + session.query(self.tsdb.RegressionIndicator) + .filter_by(regression_id=reg1.id) + .first() + ) + # Try to remove reg1's indicator using reg2's id + removed = self.tsdb.remove_regression_indicator( + session, reg2.id, indicator.uuid) + self.assertFalse(removed) + session.close() + + def test_get_regression_indicator_by_uuid(self): + session = self.Session() + machine = self.tsdb.get_or_create_machine(session, "ri-get-m") + test = self.tsdb.get_or_create_test(session, "ri-get-test") + reg = self.tsdb.create_regression( + session, "get-ind", + [{"machine_id": machine.id, "test_id": test.id, + "metric": "execution_time"}], + state=0) + session.commit() + + indicator = ( + session.query(self.tsdb.RegressionIndicator) + .filter_by(regression_id=reg.id) + .first() + ) + fetched = self.tsdb.get_regression_indicator( + session, uuid=indicator.uuid) + self.assertEqual(fetched.id, indicator.id) + session.close() + + def test_get_regression_indicator_requires_id_or_uuid(self): + session = self.Session() + with self.assertRaises(ValueError): + self.tsdb.get_regression_indicator(session) + session.close() + + def test_batch_add_indicators_silently_ignores_duplicates(self): + session = self.Session() + machine = self.tsdb.get_or_create_machine(session, "ri-batch-m") + test = self.tsdb.get_or_create_test(session, "ri-batch-test") + reg = self.tsdb.create_regression( + session, "batch", + [{"machine_id": machine.id, "test_id": test.id, + "metric": "execution_time"}], + state=0) + session.commit() + + # Batch add: one duplicate, one new + test2 = self.tsdb.get_or_create_test(session, "ri-batch-test2") + session.flush() + created = self.tsdb.add_regression_indicators_batch( + session, reg, + [ + {"machine_id": machine.id, "test_id": test.id, + "metric": "execution_time"}, # duplicate + {"machine_id": machine.id, "test_id": test2.id, + "metric": "execution_time"}, # new + ]) + session.commit() + + self.assertEqual(len(created), 1) + self.assertEqual(created[0].test_id, test2.id) + session.close() +``` + + +--- + +## 5. Schema parsing changes + +File: `lnt/server/db/v5/schema.py` + +**No changes needed.** FieldChange is not referenced anywhere in the schema +parser. The parser deals with `metrics`, `commit_fields`, and +`machine_fields` -- all of which remain unchanged. + + +--- + +## 6. Verification steps + +After implementing all changes: + +1. **Run the v5 DB model tests:** + ``` + lit -sv tests/server/db/v5/test_models.py + ``` + Verify all existing tests pass and new tests pass. The table creation + test should show 7 tables instead of 8. + +2. **Run the v5 DB CRUD tests:** + ``` + lit -sv tests/server/db/v5/test_crud.py + ``` + Verify all regression-related tests pass with new signatures. + +3. **Run the full v5 test suite:** + ``` + lit -sv tests/server/db/v5/ + ``` + +4. **Run broader cross-cutting tests** to catch any references to the old + model that were missed: + ``` + lit -sv tests/ + ``` + +5. **Grep for stale references** to ensure nothing was missed in the DB layer: + ``` + grep -rn 'FieldChange\|field_change' lnt/server/db/v5/ + ``` + This should return zero results after the changes. + +6. **Verify mypy** (if type checking is configured): + ``` + tox -e mypy + ``` + +Note: Steps 4-6 may surface breakages in the API layer +(`lnt/server/api/v5/endpoints/regressions.py`, +`lnt/server/api/v5/endpoints/field_changes.py`, etc.) and other test files +that reference the old FieldChange-based model. Those are expected and will +be addressed in a separate API-layer plan. diff --git a/lnt/server/db/v5/__init__.py b/lnt/server/db/v5/__init__.py index 53d0c80e5..a6a1bb7a1 100644 --- a/lnt/server/db/v5/__init__.py +++ b/lnt/server/db/v5/__init__.py @@ -33,12 +33,10 @@ # Regression state values (see design D5). REGRESSION_STATES = { 0: "detected", - 1: "staged", - 2: "active", - 3: "not_to_be_fixed", - 4: "ignored", - 5: "fixed", - 6: "detected_fixed", + 1: "active", + 2: "not_to_be_fixed", + 3: "fixed", + 4: "false_positive", } VALID_REGRESSION_STATES = frozenset(REGRESSION_STATES) @@ -285,7 +283,6 @@ def __init__(self, v5db: V5DB, schema: TestSuiteSchema, models: SuiteModels): self.Run = models.Run self.Test = models.Test self.Sample = models.Sample - self.FieldChange = models.FieldChange self.Regression = models.Regression self.RegressionIndicator = models.RegressionIndicator @@ -423,29 +420,23 @@ def delete_commit( ) -> None: """Delete a commit by ID (cascades to runs and samples). - Raises ``ValueError`` if any FieldChanges reference this commit - (via ``start_commit_id`` or ``end_commit_id``). Those must be - deleted first. + Raises ``ValueError`` if any Regressions reference this commit + (via ``commit_id``). Those must be updated first. """ commit = session.query(self.Commit).get(commit_id) if commit is None: return - fc_count = ( - session.query(self.FieldChange) - .filter( - or_( - self.FieldChange.start_commit_id == commit_id, - self.FieldChange.end_commit_id == commit_id, - ) - ) + reg_count = ( + session.query(self.Regression) + .filter(self.Regression.commit_id == commit_id) .count() ) - if fc_count > 0: + if reg_count > 0: raise ValueError( f"Cannot delete commit {commit_id}: " - f"{fc_count} FieldChange(s) reference it; " - f"delete them first" + f"{reg_count} Regression(s) reference it; " + f"clear their commit_id first" ) session.delete(commit) @@ -920,105 +911,45 @@ def query_trends( return results # =================================================================== - # FieldChanges (CRUD only) + # Regressions (CRUD) # =================================================================== - def create_field_change( - self, - session: sqlalchemy.orm.Session, - machine, - test, - field_name: str, - start_commit, - end_commit, - old_value: float | None, - new_value: float | None, - ): - """Create a FieldChange record.""" - fc = self.FieldChange() - fc.uuid = str(uuid_module.uuid4()) - fc.machine_id = machine.id - fc.test_id = test.id - fc.field_name = field_name - fc.start_commit_id = start_commit.id - fc.end_commit_id = end_commit.id - fc.old_value = old_value - fc.new_value = new_value - session.add(fc) - session.flush() - return fc - - def get_field_change( - self, - session: sqlalchemy.orm.Session, - *, - id: int | None = None, - uuid: str | None = None, - ): - """Fetch a single FieldChange by id or uuid.""" - q = session.query(self.FieldChange) - if id is not None: - return q.filter(self.FieldChange.id == id).first() - if uuid is not None: - return q.filter(self.FieldChange.uuid == uuid).first() - raise ValueError("must specify id or uuid") - - def list_field_changes( - self, - session: sqlalchemy.orm.Session, - *, - machine=None, - test=None, - metric: str | None = None, - limit: int | None = None, - ) -> list: - """List field changes with optional filters.""" - q = session.query(self.FieldChange) - if machine is not None: - q = q.filter(self.FieldChange.machine_id == machine.id) - if test is not None: - q = q.filter(self.FieldChange.test_id == test.id) - if metric is not None: - q = q.filter(self.FieldChange.field_name == metric) - return q.order_by(self.FieldChange.id).limit(limit if limit is not None else DEFAULT_LIMIT).all() - - def delete_field_change( - self, - session: sqlalchemy.orm.Session, - field_change_id: int, - ) -> None: - """Delete a field change by ID (cascades to regression indicators).""" - fc = session.query(self.FieldChange).get(field_change_id) - if fc is not None: - session.delete(fc) - session.flush() - def create_regression( self, session: sqlalchemy.orm.Session, title: str, - field_change_ids: list[int], + indicators: list[dict[str, Any]], *, bug: str | None = None, + notes: str | None = None, + commit: Any | None = None, state: int = 0, ): - """Create a Regression with the given FieldChange indicators.""" + """Create a Regression with the given indicators. + + Each dict in *indicators* must have keys ``machine_id`` (int), + ``test_id`` (int), and ``metric`` (str). + + *commit* is an optional Commit object whose id is stored on the + Regression (nullable FK). + """ _validate_regression_state(state) reg = self.Regression() reg.uuid = str(uuid_module.uuid4()) reg.title = title reg.bug = bug + reg.notes = notes reg.state = state + reg.commit_id = commit.id if commit is not None else None session.add(reg) session.flush() - indicators = [] - for fc_id in field_change_ids: - ri = self.RegressionIndicator() - ri.regression_id = reg.id - ri.field_change_id = fc_id - indicators.append(ri) - session.add_all(indicators) + ri_objects = [] + for ind in indicators: + ri_objects.append( + self._build_indicator(reg.id, ind["machine_id"], + ind["test_id"], ind["metric"])) + session.add_all(ri_objects) session.flush() return reg @@ -1037,20 +968,33 @@ def get_regression( return q.filter(self.Regression.uuid == uuid).first() raise ValueError("must specify id or uuid") + _UNSET = object() + def update_regression( self, session: sqlalchemy.orm.Session, regression, *, - title: str | None = None, - bug: str | None = None, + title: Any = _UNSET, + bug: Any = _UNSET, + notes: Any = _UNSET, + commit: Any = _UNSET, state: int | None = None, ): - """Update mutable fields on a Regression.""" - if title is not None: + """Update mutable fields on a Regression. + + For *title*, *bug*, *notes*, and *commit*: pass a value to set, + ``None`` to clear, or omit (default ``_UNSET``) to leave unchanged. + *state* uses ``None`` as "leave unchanged" (state cannot be null). + """ + if title is not self._UNSET: regression.title = title - if bug is not None: + if bug is not self._UNSET: regression.bug = bug + if notes is not self._UNSET: + regression.notes = notes + if commit is not self._UNSET: + regression.commit_id = commit.id if commit is not None else None if state is not None: _validate_regression_state(state) regression.state = state @@ -1081,31 +1025,86 @@ def delete_regression( session.delete(reg) session.flush() + def _build_indicator(self, regression_id, machine_id, test_id, metric): + """Construct a RegressionIndicator object (not yet added to session).""" + ri = self.RegressionIndicator() + ri.uuid = str(uuid_module.uuid4()) + ri.regression_id = regression_id + ri.machine_id = machine_id + ri.test_id = test_id + ri.metric = metric + return ri + def add_regression_indicator( self, session: sqlalchemy.orm.Session, regression, - field_change, + machine_id: int, + test_id: int, + metric: str, ): - """Add a FieldChange as an indicator on a Regression. + """Add an indicator to a Regression. Returns the created RegressionIndicator. Raises - ``sqlalchemy.exc.IntegrityError`` if the pair already exists. + ``sqlalchemy.exc.IntegrityError`` if the (regression, machine, + test, metric) combination already exists. """ - ri = self.RegressionIndicator() - ri.regression_id = regression.id - ri.field_change_id = field_change.id + ri = self._build_indicator(regression.id, machine_id, test_id, metric) session.add(ri) session.flush() return ri + def add_regression_indicators_batch( + self, + session: sqlalchemy.orm.Session, + regression, + indicators: list[dict[str, Any]], + ) -> list: + """Add multiple indicators to a Regression, silently ignoring duplicates. + + Each dict must have keys ``machine_id``, ``test_id``, ``metric``. + Returns the list of newly created RegressionIndicator objects + (excludes duplicates that were skipped). + + Note: the check-then-insert has a TOCTOU window under concurrent + access. The unique constraint catches this at the DB level; the + API layer is expected to serialize regression updates. + """ + # Fetch all existing indicators for this regression in one query. + existing_rows = ( + session.query( + self.RegressionIndicator.machine_id, + self.RegressionIndicator.test_id, + self.RegressionIndicator.metric, + ) + .filter_by(regression_id=regression.id) + .all() + ) + existing_keys = { + (r.machine_id, r.test_id, r.metric) for r in existing_rows + } + + created = [] + for ind in indicators: + key = (ind["machine_id"], ind["test_id"], ind["metric"]) + if key in existing_keys: + continue + ri = self._build_indicator( + regression.id, ind["machine_id"], + ind["test_id"], ind["metric"]) + session.add(ri) + created.append(ri) + existing_keys.add(key) + session.flush() + return created + def remove_regression_indicator( self, session: sqlalchemy.orm.Session, regression_id: int, - field_change_id: int, + indicator_uuid: str, ) -> bool: - """Remove a single indicator from a regression. + """Remove an indicator from a regression by UUID. Returns True if an indicator was removed, False if none matched. """ @@ -1113,7 +1112,7 @@ def remove_regression_indicator( session.query(self.RegressionIndicator) .filter( self.RegressionIndicator.regression_id == regression_id, - self.RegressionIndicator.field_change_id == field_change_id, + self.RegressionIndicator.uuid == indicator_uuid, ) .delete() ) @@ -1121,6 +1120,21 @@ def remove_regression_indicator( session.flush() return count > 0 + def get_regression_indicator( + self, + session: sqlalchemy.orm.Session, + *, + id: int | None = None, + uuid: str | None = None, + ): + """Fetch a single RegressionIndicator by id or uuid.""" + q = session.query(self.RegressionIndicator) + if id is not None: + return q.filter(self.RegressionIndicator.id == id).first() + if uuid is not None: + return q.filter(self.RegressionIndicator.uuid == uuid).first() + raise ValueError("must specify id or uuid") + # =================================================================== # Bulk import (run submission) -- helpers # =================================================================== diff --git a/lnt/server/db/v5/models.py b/lnt/server/db/v5/models.py index ae8da3974..471fdea36 100644 --- a/lnt/server/db/v5/models.py +++ b/lnt/server/db/v5/models.py @@ -105,7 +105,6 @@ class SuiteModels: Run: Any = None Test: Any = None Sample: Any = None - FieldChange: Any = None Regression: Any = None RegressionIndicator: Any = None @@ -258,59 +257,6 @@ def create_suite_models(schema: TestSuiteSchema) -> SuiteModels: Sample.run_id, Sample.test_id, # type: ignore[attr-defined] ) - # ----------------------------------------------------------------------- - # FieldChange - # ----------------------------------------------------------------------- - fc_attrs: dict[str, Any] = { - "__tablename__": f"{prefix}_FieldChange", - "id": Column("id", Integer, primary_key=True), - "uuid": Column( - "uuid", String(36), unique=True, nullable=False, index=True, - default=lambda: str(uuid_module.uuid4()), - ), - "test_id": Column( - "test_id", Integer, - ForeignKey(f"{prefix}_Test.id"), - nullable=False, index=True, - ), - "machine_id": Column( - "machine_id", Integer, - ForeignKey(f"{prefix}_Machine.id"), - nullable=False, index=True, - ), - "field_name": Column("field_name", String(256), nullable=False), - "start_commit_id": Column( - "start_commit_id", Integer, - ForeignKey(f"{prefix}_Commit.id"), - nullable=False, index=True, - ), - "end_commit_id": Column( - "end_commit_id", Integer, - ForeignKey(f"{prefix}_Commit.id"), - nullable=False, index=True, - ), - "old_value": Column("old_value", Float, nullable=True), - "new_value": Column("new_value", Float, nullable=True), - "test": relation("Test", foreign_keys=f"{prefix}_FieldChange.c.test_id"), - "machine": relation("Machine", foreign_keys=f"{prefix}_FieldChange.c.machine_id"), - "start_commit": relation( - "Commit", - foreign_keys=f"{prefix}_FieldChange.c.start_commit_id", - ), - "end_commit": relation( - "Commit", - foreign_keys=f"{prefix}_FieldChange.c.end_commit_id", - ), - } - FieldChange = type("FieldChange", (base,), fc_attrs) - - # Covers regression lookup: "field changes for a specific test on a machine" - # Compound index on (machine_id, test_id, field_name) - Index( - f"ix_{prefix}_FieldChange_machine_test_field", - FieldChange.machine_id, FieldChange.test_id, FieldChange.field_name, # type: ignore[attr-defined] - ) - # ----------------------------------------------------------------------- # Regression # ----------------------------------------------------------------------- @@ -323,7 +269,16 @@ def create_suite_models(schema: TestSuiteSchema) -> SuiteModels: ), "title": Column("title", String(256), nullable=True), "bug": Column("bug", String(256), nullable=True), + "notes": Column("notes", Text, nullable=True), "state": Column("state", Integer, nullable=False, index=True), + "commit_id": Column( + "commit_id", Integer, + ForeignKey(f"{prefix}_Commit.id"), + nullable=True, index=True, + ), + "commit_obj": relation( + "Commit", foreign_keys=f"{prefix}_Regression.c.commit_id", + ), } Regression = type("Regression", (base,), reg_attrs) @@ -333,27 +288,43 @@ def create_suite_models(schema: TestSuiteSchema) -> SuiteModels: ri_attrs: dict[str, Any] = { "__tablename__": f"{prefix}_RegressionIndicator", "id": Column("id", Integer, primary_key=True), + "uuid": Column( + "uuid", String(36), unique=True, nullable=False, index=True, + default=lambda: str(uuid_module.uuid4()), + ), "regression_id": Column( "regression_id", Integer, ForeignKey(f"{prefix}_Regression.id", ondelete="CASCADE"), nullable=False, index=True, ), - "field_change_id": Column( - "field_change_id", Integer, - ForeignKey(f"{prefix}_FieldChange.id", ondelete="CASCADE"), + "machine_id": Column( + "machine_id", Integer, + ForeignKey(f"{prefix}_Machine.id"), nullable=False, index=True, ), + "test_id": Column( + "test_id", Integer, + ForeignKey(f"{prefix}_Test.id"), + nullable=False, index=True, + ), + "metric": Column("metric", String(256), nullable=False), "__table_args__": ( - UniqueConstraint("regression_id", "field_change_id", - name=f"uq_{prefix}_ri_regression_fieldchange"), + UniqueConstraint( + "regression_id", "machine_id", "test_id", "metric", + name=f"uq_{prefix}_ri_reg_machine_test_metric", + ), ), "regression": relation( "Regression", foreign_keys=f"{prefix}_RegressionIndicator.c.regression_id", ), - "field_change": relation( - "FieldChange", - foreign_keys=f"{prefix}_RegressionIndicator.c.field_change_id", + "machine": relation( + "Machine", + foreign_keys=f"{prefix}_RegressionIndicator.c.machine_id", + ), + "test": relation( + "Test", + foreign_keys=f"{prefix}_RegressionIndicator.c.test_id", ), } RegressionIndicator = type("RegressionIndicator", (base,), ri_attrs) @@ -389,13 +360,6 @@ def create_suite_models(schema: TestSuiteSchema) -> SuiteModels: cascade="all, delete-orphan", passive_deletes=True, ) - FieldChange.regression_indicators = relation( # type: ignore[attr-defined] - RegressionIndicator, - foreign_keys=[RegressionIndicator.field_change_id], # type: ignore[attr-defined] - back_populates="field_change", - cascade="all, delete-orphan", - passive_deletes=True, - ) Regression.indicators = relation( # type: ignore[attr-defined] RegressionIndicator, foreign_keys=[RegressionIndicator.regression_id], # type: ignore[attr-defined] @@ -411,7 +375,6 @@ def create_suite_models(schema: TestSuiteSchema) -> SuiteModels: Run=Run, Test=Test, Sample=Sample, - FieldChange=FieldChange, Regression=Regression, RegressionIndicator=RegressionIndicator, ) diff --git a/tests/server/db/v5/test_crud.py b/tests/server/db/v5/test_crud.py index 31269e0dc..024041e57 100644 --- a/tests/server/db/v5/test_crud.py +++ b/tests/server/db/v5/test_crud.py @@ -154,108 +154,203 @@ def test_unknown_metadata_ignored(self): session.close() -class TestFieldChangeCRUD(unittest.TestCase): +class TestRegressionCRUD(_CRUDTestBase): - @classmethod - def setUpClass(cls): - cls.engine = _make_engine() - cls.schema = _test_schema() - cls.suite_models = create_suite_models(cls.schema) - cls.suite_models.base.metadata.drop_all(cls.engine) - cls.suite_models.base.metadata.create_all(cls.engine) - cls.Session = sqlalchemy.orm.sessionmaker(cls.engine) + def test_create_regression_with_indicators(self): + """Create a regression with machine/test/metric indicators.""" + session = self.Session() + machine = self.tsdb.get_or_create_machine(session, "reg-m") + test = self.tsdb.get_or_create_test(session, "reg-test") + session.flush() - class _FakeV5DB: - pass - cls.tsdb = V5TestSuiteDB(_FakeV5DB(), cls.schema, cls.suite_models) + reg = self.tsdb.create_regression( + session, "Perf regression", + [{"machine_id": machine.id, "test_id": test.id, + "metric": "execution_time"}], + bug="BUG-123", state=0) + session.commit() - @classmethod - def tearDownClass(cls): - cls.suite_models.base.metadata.drop_all(cls.engine) - cls.engine.dispose() + self.assertIsNotNone(reg.uuid) + self.assertEqual(reg.title, "Perf regression") + self.assertEqual(reg.bug, "BUG-123") + self.assertEqual(reg.state, 0) + self.assertIsNone(reg.notes) + self.assertIsNone(reg.commit_id) + + indicators = ( + session.query(self.tsdb.RegressionIndicator) + .filter_by(regression_id=reg.id) + .all() + ) + self.assertEqual(len(indicators), 1) + self.assertEqual(indicators[0].machine_id, machine.id) + self.assertEqual(indicators[0].test_id, test.id) + self.assertEqual(indicators[0].metric, "execution_time") + self.assertIsNotNone(indicators[0].uuid) + session.close() - def test_field_change_crud(self): + def test_create_regression_with_notes_and_commit(self): session = self.Session() - machine = self.tsdb.get_or_create_machine(session, "fc-crud-m") - test = self.tsdb.get_or_create_test(session, "fc-crud-test") - c1 = self.tsdb.get_or_create_commit(session, "fc-crud-c1") - c2 = self.tsdb.get_or_create_commit(session, "fc-crud-c2") + commit = self.tsdb.get_or_create_commit(session, "reg-commit-1") + session.flush() - fc = self.tsdb.create_field_change( - session, machine, test, "execution_time", c1, c2, 1.0, 2.0) + reg = self.tsdb.create_regression( + session, "Noted regression", [], + notes="Caused by vectorizer change", + commit=commit, + state=1) session.commit() - # Fetch by uuid - fetched = self.tsdb.get_field_change(session, uuid=fc.uuid) - self.assertIsNotNone(fetched) - self.assertEqual(fetched.field_name, "execution_time") - self.assertEqual(fetched.old_value, 1.0) - self.assertEqual(fetched.new_value, 2.0) + self.assertEqual(reg.notes, "Caused by vectorizer change") + self.assertEqual(reg.commit_id, commit.id) + session.close() - # List - all_fcs = self.tsdb.list_field_changes(session, machine=machine) - self.assertGreater(len(all_fcs), 0) + def test_create_regression_with_empty_indicators(self): + session = self.Session() + reg = self.tsdb.create_regression( + session, "Empty regression", [], state=0) + session.commit() + self.assertIsNotNone(reg.id) + indicators = ( + session.query(self.tsdb.RegressionIndicator) + .filter_by(regression_id=reg.id) + .all() + ) + self.assertEqual(len(indicators), 0) session.close() - def test_regression_crud(self): + def test_update_regression_notes(self): session = self.Session() - machine = self.tsdb.get_or_create_machine(session, "reg-crud-m") - test = self.tsdb.get_or_create_test(session, "reg-crud-test") - c1 = self.tsdb.get_or_create_commit(session, "reg-crud-c1") - c2 = self.tsdb.get_or_create_commit(session, "reg-crud-c2") - fc = self.tsdb.create_field_change( - session, machine, test, "execution_time", c1, c2, 1.0, 3.0) - session.flush() + reg = self.tsdb.create_regression( + session, "title", [], state=0) + session.commit() + self.tsdb.update_regression( + session, reg, notes="New notes") + session.commit() + + fetched = self.tsdb.get_regression(session, id=reg.id) + self.assertEqual(fetched.notes, "New notes") + session.close() + + def test_update_regression_commit(self): + session = self.Session() + commit = self.tsdb.get_or_create_commit(session, "upd-reg-c") reg = self.tsdb.create_regression( - session, "Perf regression", [fc.id], bug="BUG-123", state=0) + session, "title", [], state=0) session.commit() - self.assertIsNotNone(reg.uuid) - # Update self.tsdb.update_regression( - session, reg, title="Updated title", state=1) + session, reg, commit=commit) session.commit() - fetched = self.tsdb.get_regression(session, uuid=reg.uuid) - self.assertEqual(fetched.title, "Updated title") - self.assertEqual(fetched.state, 1) + self.assertEqual(reg.commit_id, commit.id) - # List - all_regs = self.tsdb.list_regressions(session) - self.assertGreater(len(all_regs), 0) + self.tsdb.update_regression( + session, reg, commit=None) + session.commit() + self.assertIsNone(reg.commit_id) + session.close() - # Delete - reg_id = reg.id - self.tsdb.delete_regression(session, reg_id) + def test_update_regression_state_and_title(self): + session = self.Session() + reg = self.tsdb.create_regression( + session, "original", [], state=0) session.commit() - self.assertIsNone(self.tsdb.get_regression(session, id=reg_id)) + + self.tsdb.update_regression( + session, reg, title="Updated", state=1) + session.commit() + + fetched = self.tsdb.get_regression(session, uuid=reg.uuid) + self.assertEqual(fetched.title, "Updated") + self.assertEqual(fetched.state, 1) session.close() - def test_regression_with_empty_field_change_ids(self): + def test_delete_regression_cascades_to_indicators(self): session = self.Session() + machine = self.tsdb.get_or_create_machine(session, "del-reg-m") + test = self.tsdb.get_or_create_test(session, "del-reg-test") + session.flush() + reg = self.tsdb.create_regression( - session, "Empty regression", [], state=0) + session, "to delete", + [{"machine_id": machine.id, "test_id": test.id, + "metric": "execution_time"}], + state=0) session.commit() + reg_id = reg.id - self.assertIsNotNone(reg.id) - self.assertIsNotNone(reg.uuid) + self.tsdb.delete_regression(session, reg_id) + session.commit() - # Verify no indicators were created + self.assertIsNone(self.tsdb.get_regression(session, id=reg_id)) indicators = ( session.query(self.tsdb.RegressionIndicator) - .filter_by(regression_id=reg.id) + .filter_by(regression_id=reg_id) .all() ) self.assertEqual(len(indicators), 0) + session.close() - # Cleanup - self.tsdb.delete_regression(session, reg.id) + def test_list_regressions_by_state(self): + session = self.Session() + self.tsdb.create_regression( + session, "active-one", [], state=1) + self.tsdb.create_regression( + session, "detected-one", [], state=0) session.commit() + + active = self.tsdb.list_regressions(session, state=1) + self.assertGreater(len(active), 0) + self.assertTrue( + all(r.state == 1 for r in active)) + session.close() + + def test_update_regression_clear_nullable_fields(self): + """Verify _UNSET pattern allows clearing nullable fields to None.""" + cases = [ + ("notes", "some notes"), + ("bug", "BUG-1"), + ] + for field, initial in cases: + with self.subTest(field=field): + session = self.Session() + reg = self.tsdb.create_regression( + session, "title", [], **{field: initial}, state=0) + session.commit() + self.assertEqual(getattr(reg, field), initial) + + self.tsdb.update_regression(session, reg, **{field: None}) + session.commit() + self.assertIsNone(getattr(reg, field)) + session.close() + + def test_update_regression_clear_title(self): + """Verify _UNSET pattern allows clearing title to None.""" + session = self.Session() + reg = self.tsdb.create_regression( + session, "a title", [], state=0) + session.commit() + + self.tsdb.update_regression(session, reg, title=None) + session.commit() + self.assertIsNone(reg.title) + session.close() + + def test_old_state_values_rejected(self): + """States 5 and 6 (old staged/detected_fixed) must be rejected.""" + session = self.Session() + with self.assertRaises(ValueError): + self.tsdb.create_regression( + session, "old state", [], state=5) + with self.assertRaises(ValueError): + self.tsdb.create_regression( + session, "old state", [], state=6) session.close() class TestDeleteCommit(unittest.TestCase): - """Deletion cascades to runs/samples but is blocked by FieldChanges.""" + """Deletion cascades to runs/samples but is blocked by Regressions.""" @classmethod def setUpClass(cls): @@ -307,25 +402,19 @@ def test_delete_commit_cascades_to_runs_and_samples(self): self.assertEqual(len(samples), 0) session.close() - def test_delete_commit_blocked_by_field_changes(self): - """Cannot delete a commit referenced by FieldChanges.""" + def test_delete_commit_blocked_by_regression_commit_ref(self): + """Cannot delete a commit referenced by a Regression's commit_id.""" session = self.Session() - machine = self.tsdb.get_or_create_machine(session, "del-commit-m2") - test = self.tsdb.get_or_create_test(session, "del-commit-test2") - c1 = self.tsdb.get_or_create_commit(session, "del-commit-fc-c1") - c2 = self.tsdb.get_or_create_commit(session, "del-commit-fc-c2") - - self.tsdb.create_field_change( - session, machine, test, "execution_time", c1, c2, 1.0, 2.0) + commit = self.tsdb.get_or_create_commit(session, "del-commit-reg-c") session.flush() - # Cannot delete c1 (start_commit_id) - with self.assertRaises(ValueError): - self.tsdb.delete_commit(session, c1.id) + self.tsdb.create_regression( + session, "blocking reg", [], + commit=commit, state=0) + session.flush() - # Cannot delete c2 (end_commit_id) with self.assertRaises(ValueError): - self.tsdb.delete_commit(session, c2.id) + self.tsdb.delete_commit(session, commit.id) session.close() @@ -497,122 +586,177 @@ def test_update_machine_ignores_unknown_fields(self): session.close() -class TestDeleteFieldChange(_CRUDTestBase): +class TestRegressionIndicatorManagement(_CRUDTestBase): - def test_delete_field_change(self): + def test_add_regression_indicator(self): session = self.Session() - machine = self.tsdb.get_or_create_machine(session, "dfc-m") - test = self.tsdb.get_or_create_test(session, "dfc-test") - c1 = self.tsdb.get_or_create_commit(session, "dfc-c1") - c2 = self.tsdb.get_or_create_commit(session, "dfc-c2") - fc = self.tsdb.create_field_change( - session, machine, test, "execution_time", c1, c2, 1.0, 2.0) - session.commit() - fc_id = fc.id + machine = self.tsdb.get_or_create_machine(session, "ri-add-m") + test = self.tsdb.get_or_create_test(session, "ri-add-test") + reg = self.tsdb.create_regression( + session, "add-ind", [], state=0) + session.flush() - self.tsdb.delete_field_change(session, fc_id) + ri = self.tsdb.add_regression_indicator( + session, reg, machine.id, test.id, "execution_time") session.commit() - self.assertIsNone(self.tsdb.get_field_change(session, id=fc_id)) + self.assertIsNotNone(ri.id) + self.assertIsNotNone(ri.uuid) + self.assertEqual(ri.machine_id, machine.id) + self.assertEqual(ri.test_id, test.id) + self.assertEqual(ri.metric, "execution_time") session.close() - def test_delete_field_change_cascades_to_indicators(self): + def test_add_duplicate_indicator_rejected(self): session = self.Session() - machine = self.tsdb.get_or_create_machine(session, "dfc-m2") - test = self.tsdb.get_or_create_test(session, "dfc-test2") - c1 = self.tsdb.get_or_create_commit(session, "dfc-c3") - c2 = self.tsdb.get_or_create_commit(session, "dfc-c4") - fc = self.tsdb.create_field_change( - session, machine, test, "execution_time", c1, c2, 1.0, 2.0) + machine = self.tsdb.get_or_create_machine(session, "ri-dup-m") + test = self.tsdb.get_or_create_test(session, "ri-dup-test") reg = self.tsdb.create_regression( - session, "test reg", [fc.id], state=0) - session.commit() - - fc_id = fc.id - reg_id = reg.id - - # Delete field change -- should also remove the indicator - self.tsdb.delete_field_change(session, fc_id) + session, "dup-ind", + [{"machine_id": machine.id, "test_id": test.id, + "metric": "execution_time"}], + state=0) session.commit() - indicators = ( - session.query(self.tsdb.RegressionIndicator) - .filter_by(regression_id=reg_id) - .all() - ) - self.assertEqual(len(indicators), 0) + with self.assertRaises(sqlalchemy.exc.IntegrityError): + self.tsdb.add_regression_indicator( + session, reg, machine.id, test.id, "execution_time") + session.rollback() session.close() - def test_delete_nonexistent_field_change(self): + def test_same_triple_on_different_regressions_ok(self): session = self.Session() - # Should not raise - self.tsdb.delete_field_change(session, 999999) - session.close() - + machine = self.tsdb.get_or_create_machine(session, "ri-multi-m") + test = self.tsdb.get_or_create_test(session, "ri-multi-test") + reg1 = self.tsdb.create_regression( + session, "reg1", [], state=0) + reg2 = self.tsdb.create_regression( + session, "reg2", [], state=0) + session.flush() -class TestRegressionIndicatorManagement(_CRUDTestBase): + ri1 = self.tsdb.add_regression_indicator( + session, reg1, machine.id, test.id, "execution_time") + ri2 = self.tsdb.add_regression_indicator( + session, reg2, machine.id, test.id, "execution_time") + session.commit() - def _make_fc(self, session, suffix=""): - machine = self.tsdb.get_or_create_machine(session, f"ri-m{suffix}") - test = self.tsdb.get_or_create_test(session, f"ri-test{suffix}") - c1 = self.tsdb.get_or_create_commit(session, f"ri-c1{suffix}") - c2 = self.tsdb.get_or_create_commit(session, f"ri-c2{suffix}") - return self.tsdb.create_field_change( - session, machine, test, "execution_time", c1, c2, 1.0, 2.0) + self.assertIsNotNone(ri1.id) + self.assertIsNotNone(ri2.id) + session.close() - def test_add_regression_indicator(self): + def test_remove_regression_indicator_by_uuid(self): session = self.Session() - fc = self._make_fc(session, "-add") - reg = self.tsdb.create_regression(session, "add-ind", [], state=0) - session.flush() + machine = self.tsdb.get_or_create_machine(session, "ri-rem-m") + test = self.tsdb.get_or_create_test(session, "ri-rem-test") + reg = self.tsdb.create_regression( + session, "rem-ind", + [{"machine_id": machine.id, "test_id": test.id, + "metric": "execution_time"}], + state=0) + session.commit() - ri = self.tsdb.add_regression_indicator(session, reg, fc) + indicator = ( + session.query(self.tsdb.RegressionIndicator) + .filter_by(regression_id=reg.id) + .first() + ) + removed = self.tsdb.remove_regression_indicator( + session, reg.id, indicator.uuid) session.commit() + self.assertTrue(removed) - self.assertIsNotNone(ri.id) - indicators = ( + remaining = ( session.query(self.tsdb.RegressionIndicator) .filter_by(regression_id=reg.id) .all() ) - self.assertEqual(len(indicators), 1) + self.assertEqual(len(remaining), 0) session.close() - def test_add_duplicate_indicator_rejected(self): + def test_remove_nonexistent_indicator(self): session = self.Session() - fc = self._make_fc(session, "-dup") - reg = self.tsdb.create_regression(session, "dup-ind", [fc.id], state=0) - session.commit() - - # Adding the same indicator again should fail - with self.assertRaises(sqlalchemy.exc.IntegrityError): - self.tsdb.add_regression_indicator(session, reg, fc) - session.rollback() + removed = self.tsdb.remove_regression_indicator( + session, 999, "nonexistent-uuid") + self.assertFalse(removed) session.close() - def test_remove_regression_indicator(self): + def test_remove_indicator_wrong_regression(self): + """Indicator exists but belongs to a different regression.""" session = self.Session() - fc = self._make_fc(session, "-rem") - reg = self.tsdb.create_regression(session, "rem-ind", [fc.id], state=0) + machine = self.tsdb.get_or_create_machine(session, "ri-wrong-m") + test = self.tsdb.get_or_create_test(session, "ri-wrong-test") + reg1 = self.tsdb.create_regression( + session, "reg1", + [{"machine_id": machine.id, "test_id": test.id, + "metric": "execution_time"}], + state=0) + reg2 = self.tsdb.create_regression( + session, "reg2", [], state=0) session.commit() + indicator = ( + session.query(self.tsdb.RegressionIndicator) + .filter_by(regression_id=reg1.id) + .first() + ) + # Try to remove reg1's indicator using reg2's id removed = self.tsdb.remove_regression_indicator( - session, reg.id, fc.id) + session, reg2.id, indicator.uuid) + self.assertFalse(removed) + session.close() + + def test_get_regression_indicator_by_uuid(self): + session = self.Session() + machine = self.tsdb.get_or_create_machine(session, "ri-get-m") + test = self.tsdb.get_or_create_test(session, "ri-get-test") + reg = self.tsdb.create_regression( + session, "get-ind", + [{"machine_id": machine.id, "test_id": test.id, + "metric": "execution_time"}], + state=0) session.commit() - self.assertTrue(removed) - indicators = ( + indicator = ( session.query(self.tsdb.RegressionIndicator) .filter_by(regression_id=reg.id) - .all() + .first() ) - self.assertEqual(len(indicators), 0) + fetched = self.tsdb.get_regression_indicator( + session, uuid=indicator.uuid) + self.assertEqual(fetched.id, indicator.id) session.close() - def test_remove_nonexistent_indicator(self): + def test_get_regression_indicator_requires_id_or_uuid(self): session = self.Session() - removed = self.tsdb.remove_regression_indicator(session, 999, 999) - self.assertFalse(removed) + with self.assertRaises(ValueError): + self.tsdb.get_regression_indicator(session) + session.close() + + def test_batch_add_indicators_silently_ignores_duplicates(self): + session = self.Session() + machine = self.tsdb.get_or_create_machine(session, "ri-batch-m") + test = self.tsdb.get_or_create_test(session, "ri-batch-test") + reg = self.tsdb.create_regression( + session, "batch", + [{"machine_id": machine.id, "test_id": test.id, + "metric": "execution_time"}], + state=0) + session.commit() + + test2 = self.tsdb.get_or_create_test(session, "ri-batch-test2") + session.flush() + created = self.tsdb.add_regression_indicators_batch( + session, reg, + [ + {"machine_id": machine.id, "test_id": test.id, + "metric": "execution_time"}, # duplicate + {"machine_id": machine.id, "test_id": test2.id, + "metric": "execution_time"}, # new + ]) + session.commit() + + self.assertEqual(len(created), 1) + self.assertEqual(created[0].test_id, test2.id) session.close() diff --git a/tests/server/db/v5/test_models.py b/tests/server/db/v5/test_models.py index acbfe9ea9..9f94cc192 100644 --- a/tests/server/db/v5/test_models.py +++ b/tests/server/db/v5/test_models.py @@ -93,12 +93,12 @@ def test_sample_table_has_metric_columns(self): self.assertIn("compile_status", cols) def test_all_tables_created(self): - """All 8 per-suite tables should exist.""" + """All 7 per-suite tables should exist.""" insp = sqlalchemy.inspect(self.engine) tables = set(insp.get_table_names()) expected = { "t_Commit", "t_Machine", "t_Run", "t_Test", - "t_Sample", "t_FieldChange", "t_Regression", + "t_Sample", "t_Regression", "t_RegressionIndicator", } self.assertTrue(expected.issubset(tables), f"Missing: {expected - tables}") @@ -261,7 +261,8 @@ def test_jsonb_nested_parameters(self): session.close() -class TestRunCRUD(unittest.TestCase): +class _ModelTestBase(unittest.TestCase): + """Shared setup/teardown and helpers for model-level tests.""" @classmethod def setUpClass(cls): @@ -277,7 +278,7 @@ def tearDownClass(cls): cls.models.base.metadata.drop_all(cls.engine) cls.engine.dispose() - def _make_machine(self, session, name="run-test-machine"): + def _make_machine(self, session, name): m = self.models.Machine() m.name = name m.parameters = {} @@ -285,13 +286,23 @@ def _make_machine(self, session, name="run-test-machine"): session.flush() return m - def _make_commit(self, session, commit_str="test-commit"): + def _make_test(self, session, name): + t = self.models.Test() + t.name = name + session.add(t) + session.flush() + return t + + def _make_commit(self, session, commit_str): c = self.models.Commit() c.commit = commit_str session.add(c) session.flush() return c + +class TestRunCRUD(_ModelTestBase): + def test_create_run_with_commit(self): session = self.Session() machine = self._make_machine(session, "run-m-1") @@ -447,96 +458,191 @@ def test_test_name_unique(self): session.close() -class TestFieldChangeAndRegression(unittest.TestCase): +class TestRegressionAndIndicatorModels(_ModelTestBase): - @classmethod - def setUpClass(cls): - cls.engine = _make_engine() - cls.schema = _test_schema() - cls.models = create_suite_models(cls.schema) - cls.models.base.metadata.drop_all(cls.engine) - cls.models.base.metadata.create_all(cls.engine) - cls.Session = sqlalchemy.orm.sessionmaker(cls.engine) + def test_create_regression_with_commit_and_notes(self): + """Create a Regression with commit_id and notes.""" + session = self.Session() + c = self._make_commit(session, "reg-model-c1") - @classmethod - def tearDownClass(cls): - cls.models.base.metadata.drop_all(cls.engine) - cls.engine.dispose() + reg = self.models.Regression() + reg.uuid = "reg-model-uuid-00000000000000000"[:36] + reg.title = "Test Regression" + reg.bug = "BUG-1" + reg.notes = "Some notes about the regression" + reg.state = 0 + reg.commit_id = c.id + session.add(reg) + session.commit() - def _setup(self, session, suffix=""): - m = self.models.Machine() - m.name = f"fc-machine{suffix}" - m.parameters = {} - session.add(m) + self.assertIsNotNone(reg.id) + self.assertEqual(reg.notes, "Some notes about the regression") + self.assertEqual(reg.commit_id, c.id) + session.close() - t = self.models.Test() - t.name = f"fc-test{suffix}" - session.add(t) + def test_regression_commit_id_nullable(self): + """Regression without a commit_id should persist with NULL.""" + session = self.Session() + reg = self.models.Regression() + reg.uuid = "reg-model-uuid-null-commit0000000"[:36] + reg.title = "No commit regression" + reg.state = 0 + session.add(reg) + session.commit() - c1 = self.models.Commit() - c1.commit = f"fc-start{suffix}" - session.add(c1) + self.assertIsNotNone(reg.id) + self.assertIsNone(reg.commit_id) + session.close() - c2 = self.models.Commit() - c2.commit = f"fc-end{suffix}" - session.add(c2) + def test_regression_indicator_has_uuid(self): + """RegressionIndicator should have a uuid field.""" + session = self.Session() + m = self._make_machine(session, "ri-model-m1") + t = self._make_test(session, "ri-model-t1") + reg = self.models.Regression() + reg.uuid = "reg-model-uuid-ri-uuid0000000000"[:36] + reg.title = "RI UUID test" + reg.state = 0 + session.add(reg) session.flush() - return m, t, c1, c2 - def test_create_field_change(self): - session = self.Session() - m, t, c1, c2 = self._setup(session, "-create") - - fc = self.models.FieldChange() - fc.uuid = "fc-uuid-0000000000000000000000000"[:36] - fc.machine_id = m.id - fc.test_id = t.id - fc.field_name = "compile_time" - fc.start_commit_id = c1.id - fc.end_commit_id = c2.id - fc.old_value = 1.0 - fc.new_value = 2.0 - session.add(fc) + ri = self.models.RegressionIndicator() + ri.uuid = "ri-model-uuid-000000000000000000"[:36] + ri.regression_id = reg.id + ri.machine_id = m.id + ri.test_id = t.id + ri.metric = "execution_time" + session.add(ri) session.commit() - self.assertIsNotNone(fc.id) + + self.assertIsNotNone(ri.id) + self.assertEqual(ri.uuid, "ri-model-uuid-000000000000000000"[:36]) session.close() def test_regression_indicator_unique_constraint(self): - """Duplicate (regression_id, field_change_id) should fail.""" + """Duplicate (regression_id, machine_id, test_id, metric) should fail.""" session = self.Session() - m, t, c1, c2 = self._setup(session, "-uniq") - - fc = self.models.FieldChange() - fc.uuid = "fc-uuid-uniq00000000000000000000"[:36] - fc.machine_id = m.id - fc.test_id = t.id - fc.field_name = "execution_time" - fc.start_commit_id = c1.id - fc.end_commit_id = c2.id - fc.old_value = 1.0 - fc.new_value = 2.0 - session.add(fc) - session.flush() + m = self._make_machine(session, "ri-model-m-uniq") + t = self._make_test(session, "ri-model-t-uniq") reg = self.models.Regression() - reg.uuid = "reg-uuid-uniq0000000000000000000"[:36] - reg.title = "Test Regression" + reg.uuid = "reg-model-uuid-uniq00000000000000"[:36] + reg.title = "Unique constraint test" reg.state = 0 session.add(reg) session.flush() ri1 = self.models.RegressionIndicator() + ri1.uuid = "ri-model-uuid-uniq1-00000000000000"[:36] ri1.regression_id = reg.id - ri1.field_change_id = fc.id + ri1.machine_id = m.id + ri1.test_id = t.id + ri1.metric = "execution_time" session.add(ri1) session.flush() ri2 = self.models.RegressionIndicator() + ri2.uuid = "ri-model-uuid-uniq2-00000000000000"[:36] ri2.regression_id = reg.id - ri2.field_change_id = fc.id + ri2.machine_id = m.id + ri2.test_id = t.id + ri2.metric = "execution_time" + session.add(ri2) + with self.assertRaises(sqlalchemy.exc.IntegrityError): + session.flush() + session.rollback() + session.close() + + def test_same_triple_on_different_regressions_ok(self): + """Same (machine, test, metric) on different regressions should succeed.""" + session = self.Session() + m = self._make_machine(session, "ri-model-m-multi") + t = self._make_test(session, "ri-model-t-multi") + + reg1 = self.models.Regression() + reg1.uuid = "reg-model-uuid-multi1-000000000000"[:36] + reg1.title = "Reg 1" + reg1.state = 0 + session.add(reg1) + + reg2 = self.models.Regression() + reg2.uuid = "reg-model-uuid-multi2-000000000000"[:36] + reg2.title = "Reg 2" + reg2.state = 0 + session.add(reg2) + session.flush() + + ri1 = self.models.RegressionIndicator() + ri1.uuid = "ri-model-uuid-multi1-000000000000"[:36] + ri1.regression_id = reg1.id + ri1.machine_id = m.id + ri1.test_id = t.id + ri1.metric = "execution_time" + session.add(ri1) + + ri2 = self.models.RegressionIndicator() + ri2.uuid = "ri-model-uuid-multi2-000000000000"[:36] + ri2.regression_id = reg2.id + ri2.machine_id = m.id + ri2.test_id = t.id + ri2.metric = "execution_time" session.add(ri2) + session.commit() + + self.assertIsNotNone(ri1.id) + self.assertIsNotNone(ri2.id) + session.close() + + def test_delete_regression_cascades_to_indicators(self): + """Deleting a Regression should cascade-delete its indicators.""" + session = self.Session() + m = self._make_machine(session, "ri-model-m-cascade") + t = self._make_test(session, "ri-model-t-cascade") + + reg = self.models.Regression() + reg.uuid = "reg-model-uuid-cascade00000000000"[:36] + reg.title = "Cascade test" + reg.state = 0 + session.add(reg) + session.flush() + + ri = self.models.RegressionIndicator() + ri.uuid = "ri-model-uuid-cascade00000000000"[:36] + ri.regression_id = reg.id + ri.machine_id = m.id + ri.test_id = t.id + ri.metric = "execution_time" + session.add(ri) + session.flush() + + reg_id = reg.id + session.delete(reg) + session.commit() + + remaining = ( + session.query(self.models.RegressionIndicator) + .filter_by(regression_id=reg_id) + .all() + ) + self.assertEqual(len(remaining), 0) + session.close() + + def test_commit_referenced_by_regression_cannot_be_deleted(self): + """Deleting a Commit referenced by Regression.commit_id should fail.""" + session = self.Session() + c = self._make_commit(session, "reg-model-c-fk") + + reg = self.models.Regression() + reg.uuid = "reg-model-uuid-fk-commit0000000"[:36] + reg.title = "FK test" + reg.state = 0 + reg.commit_id = c.id + session.add(reg) + session.commit() + with self.assertRaises(sqlalchemy.exc.IntegrityError): + session.delete(c) session.flush() session.rollback() session.close() From 85ceeee3485c506780b5a809ba0609d9c6f0f6e9 Mon Sep 17 00:00:00 2001 From: Louis Dionne Date: Wed, 15 Apr 2026 11:00:44 -0400 Subject: [PATCH 067/143] [Docs] Add implementation plans for regression DB and API rewrites Detailed implementation plans for the regression model redesign: - v5-regression-db-implementation-plan.md: DB layer (already implemented) - v5-regression-api-implementation-plan.md: API layer (next step) Co-Authored-By: Claude Opus 4.6 (1M context) --- docs/v5-regression-api-implementation-plan.md | 1517 +++++++++++++++++ 1 file changed, 1517 insertions(+) create mode 100644 docs/v5-regression-api-implementation-plan.md diff --git a/docs/v5-regression-api-implementation-plan.md b/docs/v5-regression-api-implementation-plan.md new file mode 100644 index 000000000..6d3448736 --- /dev/null +++ b/docs/v5-regression-api-implementation-plan.md @@ -0,0 +1,1517 @@ +# v5 Regression API Rewrite: Implementation Plan + +This plan covers all changes needed to align the API layer with the redesigned +v5 regression model (FieldChange dropped, RegressionIndicator stores +machine/test/metric directly, 5 regression states, no merge/split). + +The DB layer is already done (commit 23e8e34). This plan covers the API +endpoints, schemas, helpers, blueprint registration, tests, and cross-cutting +files that reference the old model. + +--- + +## 1. Files to Delete + +### 1a. `lnt/server/api/v5/endpoints/field_changes.py` (entire file) + +The FieldChange table no longer exists. Delete the whole file (137 lines). + +### 1b. `tests/server/api/v5/test_field_changes.py` (entire file) + +All tests here exercise the deleted endpoint. Delete the whole file (607 lines). + +--- + +## 2. Schema Changes: `lnt/server/api/v5/schemas/regressions.py` + +### 2a. Update STATE_TO_DB (lines 19-27) + +The old mapping has 7 states (detected=0, staged=1, active=2, +not_to_be_fixed=3, ignored=4, fixed=5, detected_fixed=6). The new model has 5 +states aligned with the DB layer values in `lnt/server/db/v5/__init__.py` +lines 34-40. + +Replace: + +```python +STATE_TO_DB = { + 'detected': 0, + 'staged': 1, + 'active': 2, + 'not_to_be_fixed': 3, + 'ignored': 4, + 'fixed': 5, + 'detected_fixed': 6, +} +``` + +With: + +```python +STATE_TO_DB = { + 'detected': 0, + 'active': 1, + 'not_to_be_fixed': 2, + 'fixed': 3, + 'false_positive': 4, +} +``` + +`DB_TO_STATE`, `VALID_STATES`, `state_to_api`, and `state_to_db` remain +unchanged (they derive from STATE_TO_DB). + +### 2b. Drop all FieldChange-related schemas + +Delete these classes entirely: + +- `FieldChangeResponseSchema` (lines 98-131) +- `FieldChangeCreateSchema` (lines 134-164) +- `PaginatedFieldChangeResponseSchema` (lines 284-286) +- `FieldChangeListQuerySchema` (lines 319-332) + +### 2c. Drop merge/split schemas + +Delete these classes: + +- `RegressionMergeSchema` (lines 208-215) +- `RegressionSplitSchema` (lines 218-225) + +### 2d. Rewrite IndicatorResponseSchema (lines 60-95) + +The old schema references `field_change_uuid`, `old_value`, `new_value`, +`start_commit`, `end_commit`. The new model is simpler: indicators directly +have `uuid`, `machine`, `test`, `metric`. + +Replace with: + +```python +class IndicatorResponseSchema(BaseSchema): + """Schema for a single regression indicator.""" + uuid = ma.fields.String( + required=True, + metadata={'description': 'Indicator UUID'}, + ) + machine = ma.fields.String( + required=True, + metadata={'description': 'Name of the machine'}, + ) + test = ma.fields.String( + required=True, + metadata={'description': 'Name of the test'}, + ) + metric = ma.fields.String( + required=True, + metadata={'description': 'Metric name'}, + ) +``` + +### 2e. Rewrite IndicatorAddSchema (lines 228-233) + +Old: `{field_change_uuid: "..."}` (single). New: batch array of +`{machine, test, metric}` objects. + +Replace with: + +```python +class IndicatorAddSchema(BaseSchema): + """Schema for POST /regressions/{uuid}/indicators request body.""" + indicators = ma.fields.List( + ma.fields.Nested(IndicatorInputSchema), + required=True, + validate=ma.validate.Length(min=1), + metadata={'description': 'List of {machine, test, metric} indicators to add'}, + ) +``` + +This requires a new nested schema: + +```python +class IndicatorInputSchema(BaseSchema): + """Schema for a single indicator input ({machine, test, metric}).""" + machine = ma.fields.String( + required=True, + metadata={'description': 'Machine name'}, + ) + test = ma.fields.String( + required=True, + metadata={'description': 'Test name'}, + ) + metric = ma.fields.String( + required=True, + metadata={'description': 'Metric name'}, + ) +``` + +Place `IndicatorInputSchema` before `IndicatorAddSchema` so it can be +referenced. + +### 2f. Add IndicatorRemoveSchema (new) + +```python +class IndicatorRemoveSchema(BaseSchema): + """Schema for DELETE /regressions/{uuid}/indicators request body.""" + indicator_uuids = ma.fields.List( + ma.fields.String(), + required=True, + validate=ma.validate.Length(min=1), + metadata={'description': 'UUIDs of indicators to remove'}, + ) +``` + +### 2g. Rewrite RegressionCreateSchema (lines 170-191) + +Old: `{field_change_uuids: [...], title, bug, state}`. New: `{title, bug, +notes, state, commit, indicators: [{machine, test, metric}]}`. + +Replace with: + +```python +class RegressionCreateSchema(BaseSchema): + """Schema for POST /regressions request body.""" + title = ma.fields.String( + load_default=None, + metadata={'description': 'Optional title (auto-generated if omitted)'}, + ) + bug = ma.fields.String( + load_default=None, + metadata={'description': 'Optional bug URL'}, + ) + notes = ma.fields.String( + load_default=None, + metadata={'description': 'Optional investigation notes'}, + ) + state = ma.fields.String( + load_default=None, + validate=ma.validate.OneOf(VALID_STATES), + metadata={'description': 'Optional initial state (default: detected)', + 'enum': VALID_STATES}, + ) + commit = ma.fields.String( + load_default=None, + metadata={'description': 'Optional suspected introduction commit (resolved by value)'}, + ) + indicators = ma.fields.List( + ma.fields.Nested(IndicatorInputSchema), + load_default=[], + metadata={'description': 'Optional list of {machine, test, metric} indicators'}, + ) +``` + +Note: `indicators` is optional (defaults to empty list, matching the API spec +which says "optional"). `field_change_uuids` is removed. + +### 2h. Rewrite RegressionUpdateSchema (lines 194-205) + +Old: `{title, bug, state}`. New: adds `notes` and `commit`. + +Replace with: + +```python +class RegressionUpdateSchema(BaseSchema): + """Schema for PATCH /regressions/{uuid} request body.""" + title = ma.fields.String( + metadata={'description': 'New title'}, + ) + bug = ma.fields.String( + allow_none=True, + metadata={'description': 'New bug URL (null to clear)'}, + ) + notes = ma.fields.String( + allow_none=True, + metadata={'description': 'New notes (null to clear)'}, + ) + state = ma.fields.String( + validate=ma.validate.OneOf(VALID_STATES), + metadata={'description': 'New state', 'enum': VALID_STATES}, + ) + commit = ma.fields.String( + allow_none=True, + metadata={'description': 'Suspected introduction commit (null to clear)'}, + ) +``` + +`bug`, `notes`, and `commit` need `allow_none=True` so clients can send +`null` to explicitly clear the field. The PATCH handler (section 3h) uses +`'key' in body` checks to distinguish absent vs present fields, and only +passes present fields to the DB layer via `**kwargs`. + +### 2i. Rewrite RegressionListItemSchema (lines 240-251) + +Old: `{uuid, title, bug, state}`. New: adds `commit`, `machine_count`, +`test_count` per the spec (line 106 of v5-api.md). + +Replace with: + +```python +class RegressionListItemSchema(BaseSchema): + """Schema for a regression in list responses.""" + uuid = ma.fields.String(required=True) + title = ma.fields.String(allow_none=True) + bug = ma.fields.String(allow_none=True) + state = ma.fields.String( + required=True, + metadata={'description': 'Regression state', 'enum': VALID_STATES}, + ) + commit = ma.fields.String( + allow_none=True, + metadata={'description': 'Suspected introduction commit (identity string)'}, + ) + machine_count = ma.fields.Integer( + metadata={'description': 'Number of distinct machines across indicators'}, + ) + test_count = ma.fields.Integer( + metadata={'description': 'Number of distinct tests across indicators'}, + ) +``` + +### 2j. Rewrite RegressionDetailSchema (lines 253-267) + +Old: `{uuid, title, bug, state, indicators}`. New: adds `notes`, `commit`. + +Replace with: + +```python +class RegressionDetailSchema(BaseSchema): + """Schema for a single regression detail response.""" + uuid = ma.fields.String(required=True) + title = ma.fields.String(allow_none=True) + bug = ma.fields.String(allow_none=True) + notes = ma.fields.String( + allow_none=True, + metadata={'description': 'Investigation notes'}, + ) + state = ma.fields.String( + required=True, + metadata={'description': 'Regression state', 'enum': VALID_STATES}, + ) + commit = ma.fields.String( + allow_none=True, + metadata={'description': 'Suspected introduction commit (identity string)'}, + ) + indicators = ma.fields.List( + ma.fields.Nested(IndicatorResponseSchema), + metadata={'description': 'Embedded list of regression indicators'}, + ) +``` + +### 2k. Drop PaginatedIndicatorResponseSchema (lines 279-281) + +Indicators are now embedded in the detail response, not separately paginated. +Delete: + +```python +class PaginatedIndicatorResponseSchema(PaginatedResponseSchema): + """Paginated list of regression indicators.""" + items = ma.fields.List(ma.fields.Nested(IndicatorResponseSchema)) +``` + +### 2l. Drop RegressionIndicatorsQuerySchema (lines 314-316) + +No more GET /regressions/{uuid}/indicators endpoint. Delete: + +```python +class RegressionIndicatorsQuerySchema(CursorPaginationQuerySchema): + """Query parameters for GET /regressions/{uuid}/indicators.""" + pass +``` + +### 2m. Update RegressionListQuerySchema (lines 293-312) + +Add `commit` and `has_commit` filter parameters per v5-api.md line 74. + +```python +class RegressionListQuerySchema(CursorPaginationQuerySchema): + """Query parameters for GET /regressions.""" + state = webargs_fields.DelimitedList( + ma.fields.String(), + load_default=[], + metadata={'description': 'Filter by state (comma-separated)'}, + ) + machine = ma.fields.String( + load_default=None, + metadata={'description': 'Filter by machine name'}, + ) + test = ma.fields.String( + load_default=None, + metadata={'description': 'Filter by test name'}, + ) + metric = ma.fields.String( + load_default=None, + metadata={'description': 'Filter by metric name'}, + ) + commit = ma.fields.String( + load_default=None, + metadata={'description': 'Filter by commit (regressions whose commit_id matches)'}, + ) + has_commit = ma.fields.Boolean( + load_default=None, + metadata={'description': 'Filter: true = has commit, false = no commit'}, + ) +``` + +--- + +## 3. Endpoint Changes: `lnt/server/api/v5/endpoints/regressions.py` + +### 3a. Update module docstring (lines 1-13) + +Replace the current docstring to reflect the new endpoint set: + +```python +"""Regression endpoints for the v5 API. + +GET /api/v5/{ts}/regressions -- List +POST /api/v5/{ts}/regressions -- Create +GET /api/v5/{ts}/regressions/{uuid} -- Detail +PATCH /api/v5/{ts}/regressions/{uuid} -- Update +DELETE /api/v5/{ts}/regressions/{uuid} -- Delete +POST /api/v5/{ts}/regressions/{uuid}/indicators -- Add indicators (batch) +DELETE /api/v5/{ts}/regressions/{uuid}/indicators -- Remove indicators (batch) +""" +``` + +### 3b. Update imports (lines 15-51) + +Remove all FieldChange-related imports: + +- Remove `joinedload` from `sqlalchemy.orm` (no longer needed for eager-loading + FieldChange chains) +- Remove from `..helpers`: `lookup_fieldchange`, `serialize_fieldchange` +- Remove from `..schemas.regressions`: + `PaginatedIndicatorResponseSchema`, `RegressionIndicatorsQuerySchema`, + `RegressionMergeSchema`, `RegressionSplitSchema` +- Add new imports from `..schemas.regressions`: + `IndicatorRemoveSchema` +- Keep: `IndicatorAddSchema`, `IndicatorResponseSchema`, + `PaginatedRegressionListSchema`, `RegressionCreateSchema`, + `RegressionDetailSchema`, `RegressionListQuerySchema`, + `RegressionUpdateSchema`, `STATE_TO_DB`, `state_to_api`, `state_to_db` +- Add `lookup_commit` from `..helpers` + +Updated imports block: + +```python +from flask import g, jsonify, make_response +from flask.views import MethodView +from flask_smorest import Blueprint + +from ..auth import require_scope +from ..errors import abort_with_error, reject_unknown_params +from ..helpers import ( + lookup_commit, + lookup_machine, + lookup_regression, + lookup_test, + validate_metric_name, +) +from ..etag import add_etag_to_response +from ..pagination import ( + cursor_paginate, + make_paginated_response, +) +from ..schemas.regressions import ( + IndicatorAddSchema, + IndicatorRemoveSchema, + IndicatorResponseSchema, + PaginatedRegressionListSchema, + RegressionCreateSchema, + RegressionDetailSchema, + RegressionListQuerySchema, + RegressionUpdateSchema, + STATE_TO_DB, + state_to_api, + state_to_db, +) +``` + +### 3c. Update Blueprint description (line 53-58) + +Change: + +```python +description='Triage performance regressions: create, merge, split, and manage indicators', +``` + +To: + +```python +description='Triage performance regressions: create, update, delete, and manage indicators', +``` + +### 3d. Rewrite all helper functions (lines 62-154) + +Delete the entire old helpers section (`_fc_load_branches`, +`_indicator_load_options`, `_indicator_query_options`, `_serialize_indicator`, +`_serialize_regression_list`, `_serialize_regression_detail`, +`_validate_state`, `_lookup_regression_with_indicators`). + +Replace with: + +```python +def _serialize_indicator(ri): + """Serialize a RegressionIndicator into the API response dict.""" + return { + 'uuid': ri.uuid, + 'machine': ri.machine.name if ri.machine else None, + 'test': ri.test.name if ri.test else None, + 'metric': ri.metric, + } + + +def _serialize_regression_list(regression): + """Serialize a Regression for the list endpoint. + + Requires the regression to have indicators eagerly loaded (or + accessible) for computing machine_count and test_count. + """ + # Compute distinct machine/test counts from indicators + machines = set() + tests = set() + for ri in regression.indicators: + machines.add(ri.machine_id) + tests.add(ri.test_id) + + return { + 'uuid': regression.uuid, + 'title': regression.title, + 'bug': regression.bug, + 'state': state_to_api(regression.state), + 'commit': (regression.commit_obj.commit + if regression.commit_obj else None), + 'machine_count': len(machines), + 'test_count': len(tests), + } + + +def _serialize_regression_detail(regression): + """Serialize a Regression for the detail endpoint (with indicators).""" + serialized_indicators = [ + _serialize_indicator(ri) for ri in regression.indicators + ] + return { + 'uuid': regression.uuid, + 'title': regression.title, + 'bug': regression.bug, + 'notes': regression.notes, + 'state': state_to_api(regression.state), + 'commit': (regression.commit_obj.commit + if regression.commit_obj else None), + 'indicators': serialized_indicators, + } + + +def _validate_state(state_str): + """Validate and convert a state string to its DB integer. + + Aborts with 400 if invalid. + """ + db_state = state_to_db(state_str) + if db_state is None: + abort_with_error( + 400, + "Invalid state '%s'. Valid states: %s" + % (state_str, ', '.join(sorted(STATE_TO_DB.keys())))) + return db_state + + +def _resolve_indicators(session, ts, indicator_dicts): + """Resolve indicator input dicts to DB-ready dicts. + + Each input dict has {machine, test, metric} (names). This function + looks up each entity and returns a list of dicts with + {machine_id, test_id, metric}. + + Aborts with 404 if any machine or test is not found, 400 if metric is + unknown. + """ + resolved = [] + for ind in indicator_dicts: + machine = lookup_machine(session, ts, ind['machine']) + test = lookup_test(session, ts, ind['test']) + validate_metric_name(ts, ind['metric']) + resolved.append({ + 'machine_id': machine.id, + 'test_id': test.id, + 'metric': ind['metric'], + }) + return resolved + + +def _eager_load_regression(session, ts, regression_uuid): + """Look up a regression by UUID with eager-loaded relationships. + + Loads indicators with their machine and test relationships for + serialization. Aborts with 404 if not found. + """ + from sqlalchemy.orm import joinedload, subqueryload + + reg = ( + session.query(ts.Regression) + .options( + joinedload(ts.Regression.commit_obj), + subqueryload(ts.Regression.indicators) + .joinedload(ts.RegressionIndicator.machine), + subqueryload(ts.Regression.indicators) + .joinedload(ts.RegressionIndicator.test), + ) + .filter(ts.Regression.uuid == regression_uuid) + .first() + ) + if reg is None: + abort_with_error(404, "Regression '%s' not found" % regression_uuid) + return reg +``` + +Key design notes: +- `_serialize_indicator` now returns `{uuid, machine, test, metric}` (no + more `field_change_uuid`, `old_value`, `new_value`, `start_commit`, + `end_commit`). +- `_serialize_regression_list` now includes `commit`, `machine_count`, + `test_count` as required by the spec. +- `_serialize_regression_detail` adds `notes` and `commit`. +- `_resolve_indicators` handles the name-to-id resolution for create/add. +- `_eager_load_regression` replaces `_lookup_regression_with_indicators`, + using `joinedload` for `commit_obj` and `subqueryload` for indicators + with their machine/test relations. +- The PATCH handler uses `'key' in body` checks to distinguish absent vs null, + letting the DB layer's `_UNSET` defaults handle the rest. + +### 3e. Rewrite RegressionList.get() (lines 160-225) + +The old version JOINs through `RegressionIndicator` -> `FieldChange` to +filter by machine/test/metric. The new model has machine_id, test_id, metric +directly on `RegressionIndicator`. + +New `has_commit` and `commit` filters (from the query schema) need to be +handled. + +For the list endpoint to compute `machine_count` and `test_count`, we need +the indicators to be loaded. Use `subqueryload` for the indicators relation. + +```python +@require_scope('read') +@blp.arguments(RegressionListQuerySchema, location="query") +@blp.response(200, PaginatedRegressionListSchema) +def get(self, query_args, testsuite): + """List regressions (cursor-paginated, filterable).""" + reject_unknown_params( + {'state', 'machine', 'test', 'metric', 'commit', + 'has_commit', 'cursor', 'limit'}) + ts = g.ts + session = g.db_session + + from sqlalchemy.orm import subqueryload, joinedload + query = session.query(ts.Regression).options( + joinedload(ts.Regression.commit_obj), + subqueryload(ts.Regression.indicators), + ) + + # -- State filter -- + state_values = query_args['state'] + if state_values: + db_states = [_validate_state(sv) for sv in state_values] + query = query.filter(ts.Regression.state.in_(db_states)) + + # -- Commit filters -- + commit_value = query_args.get('commit') + if commit_value: + commit_obj = lookup_commit(session, ts, commit_value) + query = query.filter( + ts.Regression.commit_id == commit_obj.id) + + has_commit = query_args.get('has_commit') + if has_commit is True: + query = query.filter( + ts.Regression.commit_id.isnot(None)) + elif has_commit is False: + query = query.filter( + ts.Regression.commit_id.is_(None)) + + # -- Machine / test / metric filters (via indicator JOIN) -- + machine_name = query_args.get('machine') + test_name = query_args.get('test') + metric_name = query_args.get('metric') + + machine = None + if machine_name: + machine = lookup_machine(session, ts, machine_name) + test = None + if test_name: + test = lookup_test(session, ts, test_name) + if metric_name: + validate_metric_name(ts, metric_name) + + if machine or test or metric_name: + query = query.join( + ts.RegressionIndicator, + ts.RegressionIndicator.regression_id == ts.Regression.id + ) + + if machine: + query = query.filter( + ts.RegressionIndicator.machine_id == machine.id) + if test: + query = query.filter( + ts.RegressionIndicator.test_id == test.id) + if metric_name: + query = query.filter( + ts.RegressionIndicator.metric == metric_name) + + if machine or test or metric_name: + query = query.distinct() + + cursor_str = query_args.get('cursor') + limit = query_args['limit'] + items, next_cursor = cursor_paginate( + query, ts.Regression.id, cursor_str, limit) + + serialized = [_serialize_regression_list(r) for r in items] + return jsonify(make_paginated_response(serialized, next_cursor)) +``` + +Key differences from old: +- No more JOIN to `FieldChange`. Filters go directly through + `RegressionIndicator.machine_id`, `.test_id`, `.metric`. +- New `commit` and `has_commit` filters. +- `subqueryload` for indicators so `_serialize_regression_list` can compute + `machine_count`/`test_count` without N+1 queries. + +### 3f. Rewrite RegressionList.post() (lines 227-256) + +Old: `{field_change_uuids: [...]}`. New: `{title, bug, notes, state, commit, +indicators: [{machine, test, metric}]}`. + +```python +@require_scope('triage') +@blp.arguments(RegressionCreateSchema) +@blp.response(201, RegressionDetailSchema) +def post(self, body, testsuite): + """Create a new regression.""" + ts = g.ts + session = g.db_session + + state_str = body.get('state') or 'detected' + db_state = _validate_state(state_str) + + # Resolve commit by value (optional) + commit_obj = None + commit_value = body.get('commit') + if commit_value: + commit_obj = lookup_commit(session, ts, commit_value) + + # Resolve indicators (optional) + indicator_dicts = body.get('indicators') or [] + resolved = _resolve_indicators(session, ts, indicator_dicts) + + title = body.get('title') or ( + 'Regression of %d benchmarks' % len(resolved) + if resolved else 'New regression') + bug = body.get('bug') + notes = body.get('notes') + + regression = ts.create_regression( + session, title, resolved, + bug=bug, notes=notes, commit=commit_obj, state=db_state) + + # Reload with eager-loaded relationships for serialization + regression = _eager_load_regression( + session, ts, regression.uuid) + + result = _serialize_regression_detail(regression) + resp = jsonify(result) + resp.status_code = 201 + return resp +``` + +### 3g. Rewrite RegressionDetail.get() (lines 264-277) + +Add `notes` and `commit` to response (handled by the new +`_serialize_regression_detail`): + +```python +@require_scope('read') +@blp.response(200, RegressionDetailSchema) +def get(self, testsuite, regression_uuid): + """Get regression detail with embedded indicators.""" + reject_unknown_params(set()) + ts = g.ts + session = g.db_session + regression = _eager_load_regression(session, ts, regression_uuid) + data = _serialize_regression_detail(regression) + return add_etag_to_response(jsonify(data), data) +``` + +### 3h. Rewrite RegressionDetail.patch() (lines 279-298) + +Add `notes` and `commit` handling, using `_UNSET` to distinguish absent vs +null: + +```python +@require_scope('triage') +@blp.arguments(RegressionUpdateSchema) +@blp.response(200, RegressionDetailSchema) +def patch(self, body, testsuite, regression_uuid): + """Update regression title, bug, notes, state, and/or commit.""" + ts = g.ts + session = g.db_session + regression = _eager_load_regression(session, ts, regression_uuid) + + kwargs = {} + + if 'title' in body: + kwargs['title'] = body['title'] + + if 'bug' in body: + kwargs['bug'] = body['bug'] # can be None to clear + + if 'notes' in body: + kwargs['notes'] = body['notes'] # can be None to clear + + if 'state' in body: + kwargs['state'] = _validate_state(body['state']) + + if 'commit' in body: + commit_value = body['commit'] + if commit_value is None: + kwargs['commit'] = None # clear + else: + kwargs['commit'] = lookup_commit(session, ts, commit_value) + + ts.update_regression(session, regression, **kwargs) + + # Reload for serialization (relationships may have changed) + regression = _eager_load_regression(session, ts, regression_uuid) + return jsonify(_serialize_regression_detail(regression)) +``` + +The DB layer's `update_regression` already uses `_UNSET` for title/bug/notes/ +commit. If a key is not in `kwargs`, the DB method leaves it unchanged. + +### 3i. RegressionDetail.delete() (lines 300-308) + +This needs no change in logic -- the cascade handles everything. Keep as-is. + +### 3j. Delete RegressionMerge class (lines 311-371) + +Delete the entire `RegressionMerge` class and its route decorator. Merge is +not part of the v5 API. + +### 3k. Delete RegressionSplit class (lines 373-432) + +Delete the entire `RegressionSplit` class and its route decorator. Split is +not part of the v5 API. + +### 3l. Rewrite RegressionIndicators class (lines 434-496) + +Replace the old `GET` + `POST` (single add) with `POST` (batch add) + `DELETE` +(batch remove). Drop `GET` entirely (indicators are embedded in detail). + +```python +@blp.route('/regressions//indicators') +class RegressionIndicators(MethodView): + """Add and remove indicators for a regression (batch operations).""" + + @require_scope('triage') + @blp.arguments(IndicatorAddSchema) + @blp.response(200, RegressionDetailSchema) + def post(self, body, testsuite, regression_uuid): + """Add indicators to a regression (batch). + + Duplicates (same regression+machine+test+metric) are silently + ignored. + """ + ts = g.ts + session = g.db_session + regression = lookup_regression(session, ts, regression_uuid) + + indicator_dicts = body['indicators'] + resolved = _resolve_indicators(session, ts, indicator_dicts) + + ts.add_regression_indicators_batch(session, regression, resolved) + + # Reload and return full detail + regression = _eager_load_regression( + session, ts, regression_uuid) + return jsonify(_serialize_regression_detail(regression)) + + @require_scope('triage') + @blp.arguments(IndicatorRemoveSchema) + @blp.response(200, RegressionDetailSchema) + def delete(self, body, testsuite, regression_uuid): + """Remove indicators from a regression (batch, by UUID). + + Unknown UUIDs are silently ignored. + """ + ts = g.ts + session = g.db_session + regression = lookup_regression(session, ts, regression_uuid) + + for indicator_uuid in body['indicator_uuids']: + ts.remove_regression_indicator( + session, regression.id, indicator_uuid) + + # Reload and return full detail + regression = _eager_load_regression( + session, ts, regression_uuid) + return jsonify(_serialize_regression_detail(regression)) +``` + +Design notes: +- POST returns 200 (not 201) and the full regression detail, since this is a + batch operation on an existing resource. +- DELETE with body: flask-smorest supports `@blp.arguments(...)` on DELETE. + The body contains `{"indicator_uuids": [...]}`. +- Both return the full regression detail for convenience. + +### 3m. Delete RegressionIndicatorRemove class (lines 498-520) + +Delete the old single-indicator DELETE route entirely: + +```python +@blp.route( + '/regressions//indicators/') +class RegressionIndicatorRemove(MethodView): + ... +``` + +--- + +## 4. Helper Changes: `lnt/server/api/v5/helpers.py` + +### 4a. Delete `lookup_fieldchange` (lines 78-83) + +This function references `ts.get_field_change` which no longer exists. +Delete entirely. + +### 4b. Delete `serialize_fieldchange` (lines 138-154) + +This function serializes FieldChange objects which no longer exist. +Delete entirely. + +### 4c. No new helper needed + +Indicator serialization is handled in the endpoint module +(`_serialize_indicator`), not in helpers.py, because the indicator model is +simpler (no need for a shared serializer across endpoints). If desired for +consistency, a `serialize_regression_indicator` helper could be added, but +the endpoint-local helper is simpler. + +--- + +## 5. Other File Changes + +### 5a. `lnt/server/api/v5/endpoints/__init__.py` -- Remove `field_changes` registration (line 24) + +In `_ENDPOINT_MODULES`, remove the `'field_changes'` entry: + +```python +# Before: +_ENDPOINT_MODULES = [ + 'discovery', + 'test_suites', + 'commits', + 'machines', + 'runs', + 'tests', + 'samples', + 'profiles', + 'query', + 'field_changes', # <-- DELETE THIS LINE + 'regressions', + 'trends', + 'admin', +] +``` + +### 5b. `lnt/server/api/v5/endpoints/test_suites.py` -- Remove `field_changes` link (line 45) + +In `_suite_links()`, delete the `field_changes` entry: + +```python +# Delete this line: +'field_changes': prefix + '/field-changes', +``` + +### 5c. `lnt/server/api/v5/schemas/common.py` -- Remove `field_changes` from TestSuiteLinksSchema (line 58) + +Delete: + +```python +field_changes = ma.fields.String() +``` + +### 5d. `lnt/server/api/v5/endpoints/machines.py` -- Remove FieldChange cleanup from delete (lines 213-218) + +The machine delete handler currently deletes FieldChanges before deleting +the machine (because FieldChange.machine_id had no CASCADE). With FieldChange +gone, `RegressionIndicator.machine_id` has no CASCADE either, so the indicators +referencing this machine must be cleaned up. + +Replace: + +```python +# FieldChange.machine_id has no CASCADE, so delete them first. +# RegressionIndicator.field_change_id has ondelete=CASCADE, +# so those are auto-cleaned when the FieldChange is deleted. +session.query(ts.FieldChange).filter( + ts.FieldChange.machine_id == machine.id +).delete(synchronize_session='fetch') +``` + +With: + +```python +# RegressionIndicator.machine_id has no CASCADE, so delete them +# before the machine. The Regression itself remains (it may have +# other indicators on different machines). +session.query(ts.RegressionIndicator).filter( + ts.RegressionIndicator.machine_id == machine.id +).delete(synchronize_session='fetch') +``` + +### 5e. `lnt/server/api/v5/endpoints/commits.py` -- Update delete docstring (line 258) + +Change: + +``` +Returns 409 if FieldChanges reference this commit. +``` + +To: + +``` +Returns 409 if regressions reference this commit. +``` + +The actual behavior is already correct: `ts.delete_commit` raises +`ValueError` if any Regression has `commit_id` pointing to this commit. +Only the docstring is stale. + +### 5f. `lnt/server/api/v5/endpoints/agents.py` -- Update llms.txt content + +Update the LLMS_TEXT constant: + +1. Change the Regression description (line 49-51): + - Old: "A detected performance change, grouping one or more field changes" + - New: "A tracked performance change, grouping one or more indicators + (machine, test, metric triples). Has a state (detected, active, fixed, + etc.), optional title, bug link, notes, and suspected introduction commit." + +2. Remove the Field Change entry (lines 53-54): + - Delete: "- **Field Change**: A statistically significant change..." + +3. Update the endpoints list (line 79): + - Remove: `GET /api/v5/{ts}/field-changes List unassigned field changes` + +4. Update workflow item 4 (lines 117-118): + - Change to mention indicators instead of field changes. + +5. After updating the text, the `_ETAG` hash (line 126) recomputes + automatically since it's `hashlib.md5(LLMS_TEXT.encode()).hexdigest()`. + +### 5g. `lnt/server/api/v5/middleware.py` -- No changes needed + +Middleware has no references to FieldChange. + +--- + +## 6. Test Changes + +### 6a. Delete `tests/server/api/v5/test_field_changes.py` (entire file) + +Already covered in section 1b. + +### 6b. Rewrite `tests/server/api/v5/v5_test_helpers.py` + +#### Drop `create_fieldchange` (lines 110-115) + +Delete the `create_fieldchange` function. It calls `ts.create_field_change` +which no longer exists. + +#### Drop `submit_fieldchange` (lines 189-203) + +Delete the `submit_fieldchange` function. It calls +`POST /field-changes` which no longer exists. + +#### Rewrite `create_regression` (lines 118-122) + +Old: + +```python +def create_regression(session, ts, title='Test Regression', + state=0, field_changes=None): + """Create a Regression (optionally with indicators) and return it.""" + fc_ids = [fc.id for fc in field_changes] if field_changes else [] + return ts.create_regression(session, title, fc_ids, state=state) +``` + +New: + +```python +def create_regression(session, ts, title='Test Regression', + state=0, indicators=None, commit=None, + notes=None, bug=None): + """Create a Regression (optionally with indicators) and return it. + + *indicators* is a list of dicts with keys machine_id, test_id, metric. + """ + indicator_list = indicators or [] + return ts.create_regression( + session, title, indicator_list, + state=state, commit=commit, notes=notes, bug=bug) +``` + +#### Rewrite `submit_regression` (lines 206-214) + +Old: + +```python +def submit_regression(client, app, fc_uuids, state='active', + testsuite='nts'): + """Create a regression via POST and return response JSON.""" + body = {'field_change_uuids': fc_uuids, 'state': state} + resp = client.post(f'/api/v5/{testsuite}/regressions', + json=body, headers=admin_headers()) + assert resp.status_code == 201, ( + f"Regression creation failed: {resp.get_json()}") + return resp.get_json() +``` + +New: + +```python +def submit_regression(client, app, indicators=None, state='active', + title=None, commit=None, notes=None, bug=None, + testsuite='nts'): + """Create a regression via POST and return response JSON. + + *indicators* is a list of {machine, test, metric} dicts. + """ + body = {'state': state} + if indicators: + body['indicators'] = indicators + if title: + body['title'] = title + if commit: + body['commit'] = commit + if notes: + body['notes'] = notes + if bug: + body['bug'] = bug + resp = client.post(f'/api/v5/{testsuite}/regressions', + json=body, headers=admin_headers()) + assert resp.status_code == 201, ( + f"Regression creation failed: {resp.get_json()}") + return resp.get_json() +``` + +#### Add `submit_indicator_add` helper (new) + +```python +def submit_indicator_add(client, app, regression_uuid, indicators, + testsuite='nts'): + """Add indicators to a regression via POST and return response JSON.""" + resp = client.post( + f'/api/v5/{testsuite}/regressions/{regression_uuid}/indicators', + json={'indicators': indicators}, + headers=admin_headers()) + assert resp.status_code == 200, ( + f"Indicator add failed: {resp.get_json()}") + return resp.get_json() +``` + +#### Add `submit_indicator_remove` helper (new) + +```python +def submit_indicator_remove(client, app, regression_uuid, indicator_uuids, + testsuite='nts'): + """Remove indicators from a regression via DELETE and return response JSON.""" + resp = client.delete( + f'/api/v5/{testsuite}/regressions/{regression_uuid}/indicators', + json={'indicator_uuids': indicator_uuids}, + headers=admin_headers()) + assert resp.status_code == 200, ( + f"Indicator remove failed: {resp.get_json()}") + return resp.get_json() +``` + +### 6c. Rewrite `tests/server/api/v5/test_regressions.py` + +This is a comprehensive rewrite. Key structural changes: + +#### Update imports (line 16-18) + +Remove references to `submit_fieldchange`. Add references to new helpers: + +```python +from v5_test_helpers import ( + create_app, create_client, make_scoped_headers, + collect_all_pages, submit_run, submit_regression, + submit_indicator_add, submit_indicator_remove, + create_machine, create_commit, create_test, +) +``` + +#### Rewrite `_setup_regression_with_indicators` (replaces `_setup_fieldchange` and old `_setup_regression_with_indicators`) + +The old helpers created FieldChange objects via `submit_fieldchange`, then +passed their UUIDs to `submit_regression`. The new version creates +regressions directly with `{machine, test, metric}` indicators: + +```python +def _setup_regression_with_indicators(client, app, num_indicators=2, + state='active', commit=None): + """Create a regression with indicators via the API. + + Returns (regression_uuid, [indicator_uuid, ...]). + """ + tag = uuid.uuid4().hex[:8] + machine = f'reg-m-{tag}' + tests = [f'reg/test/{tag}/{i}' for i in range(num_indicators)] + + # Ensure machine and tests exist by submitting a run + submit_run(client, machine, f'reg-rev-{tag}', + [{'name': t, 'execution_time': [1.0 + i]} + for i, t in enumerate(tests)]) + + indicators = [ + {'machine': machine, 'test': t, 'metric': 'execution_time'} + for t in tests + ] + reg = submit_regression(client, app, indicators=indicators, + state=state, commit=commit) + indicator_uuids = [ind['uuid'] for ind in reg['indicators']] + return reg['uuid'], indicator_uuids +``` + +Delete `_setup_fieldchange` entirely. + +#### Rewrite test classes + +**TestRegressionList**: Update tests to use new helper. Most structure is +the same. Key changes: +- `test_list_item_has_expected_fields`: check for `commit`, `machine_count`, + `test_count` instead of checking absence of indicators. +- `test_list_filter_by_state_multiple`: use new states (`active`, `detected` + still valid). +- `test_list_filter_invalid_state_400`: unchanged. +- `test_list_filter_by_state`: remove reference to `ignored` state, use + `active` or `false_positive`. + +**TestRegressionListFilters**: Complete rewrite of the filter tests since +they no longer create FieldChanges: +- `test_list_filter_by_machine`: create regression with indicator pointing + to specific machine, filter by machine name. +- `test_list_filter_by_test`: same pattern for test name. +- `test_list_filter_by_metric`: same pattern for metric. +- Add `test_list_filter_by_commit`: create regression with commit, filter + by commit value. +- Add `test_list_filter_by_has_commit_true/false`. +- Keep 404/400 tests for nonexistent machine/test/metric. + +**TestRegressionCreate**: Rewrite for new request body: +- `test_create_regression`: send `{indicators: [{machine, test, metric}]}` + instead of `{field_change_uuids: [...]}`. +- `test_create_with_custom_title`: same pattern. +- `test_create_with_state`: same. +- `test_create_default_state_detected`: same. +- `test_create_with_commit`: new test, send `commit` field. +- `test_create_with_notes`: new test, send `notes` field. +- `test_create_empty_body_succeeds`: no required fields now (indicators + defaults to []). +- Remove `test_create_missing_field_changes_422` and + `test_create_empty_field_changes_422`. +- Remove `test_create_invalid_field_change_uuid_404`. +- Add `test_create_nonexistent_machine_404`: indicator references bad machine. +- Add `test_create_nonexistent_test_404`: indicator references bad test. +- Add `test_create_unknown_metric_400`: indicator references bad metric. +- Add `test_create_nonexistent_commit_404`: commit field references bad commit. + +**TestRegressionDetail**: Update assertions: +- `test_get_detail`: check for `notes`, `commit`, and new indicator shape + (`uuid`, `machine`, `test`, `metric` instead of `field_change_uuid`, + `old_value`, etc.). +- `test_detail_state_is_string`: update expected default state. + +**TestRegressionDetailETag**: No changes needed (works with any response shape). + +**TestRegressionUpdate**: Add tests for notes and commit: +- `test_update_notes`: patch notes. +- `test_update_commit`: patch commit. +- `test_clear_commit`: patch commit=null. +- `test_clear_notes`: patch notes=null. +- `test_update_state_any_transition`: update state names (no more `ignored`, + use `false_positive`). + +**TestRegressionDelete**: No changes needed. + +**Delete TestRegressionMerge class entirely** (lines 685-805). + +**Delete TestRegressionSplit class entirely** (lines 811-891). + +**Rewrite TestRegressionIndicators**: Complete rewrite for batch operations: +- Remove `test_list_indicators`: GET /indicators no longer exists. +- Remove `test_list_indicators_nonexistent_regression_404`. +- Rewrite `test_add_indicator`: POST with `{indicators: [{machine, test, metric}]}`. +- `test_add_duplicate_silently_ignored`: POST same indicator twice, verify + no error and no duplicate. +- `test_add_nonexistent_machine_404`. +- `test_add_nonexistent_test_404`. +- `test_add_unknown_metric_400`. +- `test_add_indicator_no_auth_401`. +- Rewrite `test_remove_indicator`: DELETE with `{indicator_uuids: [...]}`. +- Remove `test_remove_nonexistent_indicator_404` (batch remove silently + ignores unknown UUIDs). +- `test_remove_indicator_no_auth_401`. + +**Delete TestRegressionZIndicatorPagination class entirely** (lines 1042-1065). +Indicators are now embedded in detail, not separately paginated. + +**Update TestRegressionZPagination**: No changes needed (uses list endpoint). + +**Update TestRegressionUnknownParams**: +- Remove `test_regression_indicators_unknown_param_returns_400`. +- Keep list and detail unknown param tests. +- Add `test_regressions_list_commit_filter_unknown_param_400` if desired. + +### 6d. Update `tests/server/api/v5/test_regression_state_mapping.py` + +The tests import `STATE_TO_DB` and test round-trip behavior. With the new +5-state mapping, the tests should continue to work as-is because: + +- `test_all_known_states_round_trip` iterates over `STATE_TO_DB.items()`. +- `test_unknown_int_returns_unknown_prefix` tests unmapped integers. +- `test_unknown_string_returns_none` tests unmapped strings. + +No code changes needed, but verify the tests pass with the new STATE_TO_DB +values. The tests will now exercise 5 states instead of 7. + +### 6e. Update `tests/server/api/v5/test_commits.py` -- Replace FieldChange-based 409 test + +**`test_delete_with_fieldchange_409`** (lines 529-556) creates a FieldChange +referencing a commit and asserts that deleting the commit returns 409. The +FieldChange table no longer exists. + +Replace with a regression-based test: + +```python +def test_delete_with_regression_409(self): + """Delete a commit referenced by a Regression returns 409.""" + from v5_test_helpers import create_machine, create_test + db = self.app.instance.get_database("default") + session = db.make_session() + ts = db.testsuite[TS] + + c = create_commit(session, ts, + commit=f'reg-ref-{uuid.uuid4().hex[:8]}') + c_commit = c.commit + m = create_machine(session, ts, + name=f'reg-del-{uuid.uuid4().hex[:8]}') + t = create_test(session, ts, + name=f'reg-del/test/{uuid.uuid4().hex[:8]}') + + from v5_test_helpers import create_regression + create_regression( + session, ts, + indicators=[{'machine_id': m.id, 'test_id': t.id, + 'metric': 'execution_time'}], + commit=c) + session.commit() + session.close() + + resp = self.client.delete( + PREFIX + f'/commits/{c_commit}', + headers=admin_headers(), + ) + self.assertEqual(resp.status_code, 409) +``` + +Also update the imports at the top of the file to remove `create_fieldchange` +(line 531-533). + +### 6f. Update `tests/server/api/v5/test_integration.py` + +#### Remove `field_changes` from discovery links test (lines 404-410) + +In `test_discovery_nts_suite_has_all_expected_links`, update the expected keys: + +```python +# Before: +expected_keys = { + 'machines', 'commits', 'runs', 'tests', + 'regressions', 'field_changes', 'query', +} + +# After: +expected_keys = { + 'machines', 'commits', 'runs', 'tests', + 'regressions', 'query', +} +``` + +#### TestMachineCRUDWorkflow -- no FieldChange references + +Check: the machine CRUD test at lines 235-342 does not reference FieldChange +directly. It exercises create, submit, rename, delete. The machine delete +handler changes (section 5d) clean up RegressionIndicators instead of +FieldChanges, but the test does not create regressions, so no changes needed +to this test class. + +### 6g. Update `tests/server/api/v5/test_machines.py` + +Line 19 imports `create_fieldchange` from `v5_test_helpers`. Lines 341-377 +contain `test_delete_machine_with_fieldchanges` which creates a FieldChange +and links it to a regression via the old model. + +- Remove `create_fieldchange` from the import (line 19) +- Rewrite `test_delete_machine_with_fieldchanges` to use the new indicator + model: create a regression with an indicator referencing the machine, then + verify deleting the machine handles the indicator FK correctly. Rename to + `test_delete_machine_with_regression_indicators`. + +### 6h. Update `tests/server/api/v5/test_discovery.py` + +Line 49 expects `'field_changes'` in the suite links set +(`test_discovery_suite_links_are_complete`). Remove `'field_changes'` from +the expected set. + +### 6i. Additional test specifications + +The following tests were named in section 6c but need explicit specifications: + +**TestRegressionList:** +- `test_list_item_machine_and_test_counts`: Create a regression with 2 + indicators (1 machine, 2 tests). Verify `machine_count == 1` and + `test_count == 2` in the list response item. +- `test_list_filter_by_commit`: Create two regressions with different commits. + Filter `?commit=`. Verify only the matching regression is returned. +- `test_list_filter_by_has_commit_true`: Create one regression with a commit, + one without. Filter `?has_commit=true`. Verify only the one with a commit. +- `test_list_filter_by_has_commit_false`: Same setup, filter `?has_commit=false`. + Verify only the one without a commit. +- `test_list_item_commit_value`: Create a regression with a commit. Verify + the list item contains the commit string value (not just the key). + +**TestRegressionDetail:** +- `test_get_detail`: Assert `notes` and `commit` in response. Assert indicator + shape is `{uuid, machine, test, metric}`. Assert absence of old fields: + `assertNotIn('field_change_uuid', ind)`, `assertNotIn('old_value', ind)`, + `assertNotIn('new_value', ind)`, `assertNotIn('start_commit', ind)`, + `assertNotIn('end_commit', ind)`. + +**TestRegressionCreate:** +- `test_create_with_notes`: POST with `notes` field. Verify notes appears in + the 201 response. +- `test_create_with_commit`: POST with `commit` field. Verify commit string + in response. + +**TestRegressionUpdate:** +- `test_update_state_any_transition`: Replace `'ignored'` with + `'false_positive'` in both directions: `active -> false_positive -> detected`. +- `test_clear_commit`: Create with commit, PATCH `{"commit": null}`, verify + response has `commit: null`. + +**TestRegressionIndicators:** +- `test_add_duplicate_silently_ignored`: Add indicator, add same indicator + again, verify 200 and indicator count unchanged. +- `test_add_nonexistent_machine_404`: POST indicator with nonexistent machine + name, expect 404. +- `test_add_nonexistent_test_404`: Same for test name. +- `test_add_unknown_metric_400`: Same for unknown metric. +- `test_remove_multiple_batch`: Create regression with 3 indicators, remove 2 + via batch DELETE, verify response has 1 remaining. +- `test_remove_unknown_uuid_silently_ignored`: Send DELETE with a nonexistent + UUID, verify 200 with unchanged indicators. +- `test_remove_no_auth_401`: Send DELETE without auth headers, expect 401. +- `test_add_empty_list_422`: POST `{"indicators": []}`, expect 422. +- `test_remove_empty_list_422`: DELETE `{"indicator_uuids": []}`, expect 422. + +--- + +## 7. Verification Steps + +After implementing all changes, verify: + +### 7a. Unit tests (no DB) + +```bash +python tests/server/api/v5/test_regression_state_mapping.py +``` + +This runs the pure-function state mapping tests against the updated +STATE_TO_DB. + +### 7b. Full API tests (require Postgres) + +```bash +lit -sv tests/server/api/v5/test_regressions.py +lit -sv tests/server/api/v5/test_commits.py +lit -sv tests/server/api/v5/test_integration.py +lit -sv tests/server/api/v5/test_machines.py +lit -sv tests/server/api/v5/test_discovery.py +``` + +### 7c. Verify deleted files don't break anything + +```bash +# Should NOT find test_field_changes.py in tests +ls tests/server/api/v5/test_field_changes.py 2>&1 | grep "No such file" + +# Should NOT find field_changes.py in endpoints +ls lnt/server/api/v5/endpoints/field_changes.py 2>&1 | grep "No such file" +``` + +### 7d. Verify no remaining FieldChange references in v5 code + +```bash +grep -r "FieldChange\|field_change\|fieldchange" \ + lnt/server/api/v5/ tests/server/api/v5/ \ + --include="*.py" -l +``` + +This should return zero files after all changes are complete. + +### 7e. Run the full v5 test suite + +```bash +lit -sv tests/server/api/v5/ +``` + +All tests should pass. + +### 7f. Type checking + +```bash +tox -e mypy +``` + +### 7g. Linting + +```bash +tox -e flake8 +``` + +--- + +## Summary of Changes by File + +| File | Action | +|------|--------| +| `lnt/server/api/v5/endpoints/field_changes.py` | DELETE | +| `lnt/server/api/v5/schemas/regressions.py` | Rewrite (states, schemas) | +| `lnt/server/api/v5/endpoints/regressions.py` | Rewrite (endpoints, helpers) | +| `lnt/server/api/v5/helpers.py` | Remove `lookup_fieldchange`, `serialize_fieldchange` | +| `lnt/server/api/v5/endpoints/__init__.py` | Remove `field_changes` module | +| `lnt/server/api/v5/endpoints/test_suites.py` | Remove `field_changes` link | +| `lnt/server/api/v5/schemas/common.py` | Remove `field_changes` from schema | +| `lnt/server/api/v5/endpoints/machines.py` | Replace FieldChange cleanup with RegressionIndicator cleanup | +| `lnt/server/api/v5/endpoints/commits.py` | Update docstring | +| `lnt/server/api/v5/endpoints/agents.py` | Update llms.txt content | +| `tests/server/api/v5/test_field_changes.py` | DELETE | +| `tests/server/api/v5/v5_test_helpers.py` | Drop `create_fieldchange`, `submit_fieldchange`; rewrite `create_regression`, `submit_regression`; add indicator helpers | +| `tests/server/api/v5/test_regressions.py` | Comprehensive rewrite | +| `tests/server/api/v5/test_regression_state_mapping.py` | No changes (auto-adapts to new STATE_TO_DB) | +| `tests/server/api/v5/test_commits.py` | Replace FieldChange-based 409 test | +| `tests/server/api/v5/test_integration.py` | Remove `field_changes` from discovery links | +| `tests/server/api/v5/test_machines.py` | Rewrite `test_delete_machine_with_fieldchanges` for new indicator model | +| `tests/server/api/v5/test_discovery.py` | Remove `field_changes` from expected suite links set | From 310a2ad17d18ad356a247d5996a3cd9be0e03bed Mon Sep 17 00:00:00 2001 From: Louis Dionne Date: Wed, 15 Apr 2026 11:57:41 -0400 Subject: [PATCH 068/143] [API] Implement redesigned regression model: drop FieldChange, new indicators Rewrite the API layer to match the redesigned regression model: - Delete field_changes.py endpoints and test_field_changes.py - Rewrite regression schemas: 5 states, new indicator shape (uuid, machine, test, metric), commit and notes on regression, machine_count and test_count in list response - Rewrite regression endpoints: new filters (machine, test, metric, commit, has_commit), batch indicator add/remove, no merge/split - Update helpers, agents/llms.txt, test_suites links, machines delete, commits docstring, blueprint registration - Comprehensive test rewrite (71 tests, all passing) - Fix stale identity map with populate_existing() on reload queries Co-Authored-By: Claude Opus 4.6 (1M context) --- lnt/server/api/v5/endpoints/__init__.py | 1 - lnt/server/api/v5/endpoints/agents.py | 15 +- lnt/server/api/v5/endpoints/commits.py | 2 +- lnt/server/api/v5/endpoints/field_changes.py | 136 --- lnt/server/api/v5/endpoints/machines.py | 10 +- lnt/server/api/v5/endpoints/regressions.py | 491 ++++------ lnt/server/api/v5/endpoints/runs.py | 4 +- lnt/server/api/v5/endpoints/test_suites.py | 1 - lnt/server/api/v5/helpers.py | 27 - lnt/server/api/v5/schemas/common.py | 1 - lnt/server/api/v5/schemas/regressions.py | 242 ++--- tests/server/api/v5/test_commits.py | 35 +- tests/server/api/v5/test_discovery.py | 2 +- tests/server/api/v5/test_field_changes.py | 607 ------------ tests/server/api/v5/test_integration.py | 2 +- tests/server/api/v5/test_machines.py | 24 +- tests/server/api/v5/test_regressions.py | 976 ++++++++++--------- tests/server/api/v5/v5_test_helpers.py | 85 +- 18 files changed, 919 insertions(+), 1742 deletions(-) delete mode 100644 lnt/server/api/v5/endpoints/field_changes.py delete mode 100644 tests/server/api/v5/test_field_changes.py diff --git a/lnt/server/api/v5/endpoints/__init__.py b/lnt/server/api/v5/endpoints/__init__.py index 6de8ccd39..a94b318f9 100644 --- a/lnt/server/api/v5/endpoints/__init__.py +++ b/lnt/server/api/v5/endpoints/__init__.py @@ -21,7 +21,6 @@ 'samples', 'profiles', 'query', - 'field_changes', 'regressions', 'trends', 'admin', diff --git a/lnt/server/api/v5/endpoints/agents.py b/lnt/server/api/v5/endpoints/agents.py index c34a247f0..c8f1958d6 100644 --- a/lnt/server/api/v5/endpoints/agents.py +++ b/lnt/server/api/v5/endpoints/agents.py @@ -46,12 +46,9 @@ Each sample records values for the metrics defined by the test suite schema (e.g., execution_time, compile_time, code_size). -- **Regression**: A detected performance change, grouping one or more field - changes. Has a state (detected, active, fixed, ignored, etc.), optional - title, and optional bug tracker link. - -- **Field Change**: A statistically significant change in a metric value - between two commits for a specific test on a specific machine. +- **Regression**: A tracked performance change, grouping one or more indicators + (machine, test, metric triples). Has a state (detected, active, fixed, + etc.), optional title, bug link, notes, and suspected introduction commit. ## REST API (v5) @@ -76,7 +73,6 @@ GET /api/v5/{ts}/tests List tests POST /api/v5/{ts}/query Query time-series data GET /api/v5/{ts}/regressions List regressions - GET /api/v5/{ts}/field-changes List unassigned field changes ### Global Endpoints @@ -86,7 +82,7 @@ The endpoints above cover the most common read operations. The API also supports write operations (creating/updating/deleting machines, commits, -runs, regressions, field changes, test suites, and API keys) which require +runs, regressions, test suites, and API keys) which require appropriate authentication scopes. See the OpenAPI spec or Swagger UI for the complete endpoint list including all write operations. @@ -115,7 +111,8 @@ "submit" scope. 4. Check for regressions: GET /api/v5/{ts}/regressions?state=detected - to find new regressions. PATCH to update state, title, or bug link. + to find new regressions. PATCH to update state, title, bug link, notes, + or commit. Add indicators via POST /regressions/{uuid}/indicators. 5. Inspect a specific commit: GET /api/v5/{ts}/commits/{value} returns the commit detail with previous/next navigation links. Use diff --git a/lnt/server/api/v5/endpoints/commits.py b/lnt/server/api/v5/endpoints/commits.py index 2e69da94d..dafe71f9a 100644 --- a/lnt/server/api/v5/endpoints/commits.py +++ b/lnt/server/api/v5/endpoints/commits.py @@ -255,7 +255,7 @@ def patch(self, testsuite, commit_value): def delete(self, testsuite, commit_value): """Delete a commit and cascade to its runs/samples. - Returns 409 if FieldChanges reference this commit. + Returns 409 if regressions reference this commit. """ ts = g.ts session = g.db_session diff --git a/lnt/server/api/v5/endpoints/field_changes.py b/lnt/server/api/v5/endpoints/field_changes.py deleted file mode 100644 index 10c95c75e..000000000 --- a/lnt/server/api/v5/endpoints/field_changes.py +++ /dev/null @@ -1,136 +0,0 @@ -"""Field change endpoints for the v5 API. - -GET /api/v5/{ts}/field-changes -- List unassigned -POST /api/v5/{ts}/field-changes -- Create a field change -""" - -from flask import g, jsonify -from flask.views import MethodView -from flask_smorest import Blueprint -from sqlalchemy.orm import joinedload - -from ..auth import require_scope -from ..errors import reject_unknown_params -from ..helpers import ( - lookup_commit, - lookup_machine, - lookup_test, - serialize_fieldchange, - validate_metric_name, -) -from ..pagination import ( - cursor_paginate, - make_paginated_response, -) -from ..schemas.regressions import ( - FieldChangeCreateSchema, - FieldChangeListQuerySchema, - FieldChangeResponseSchema, - PaginatedFieldChangeResponseSchema, -) - -blp = Blueprint( - 'Field Changes', - __name__, - url_prefix='/api/v5/', - description='List and create significant metric changes between commits', -) - - -# --------------------------------------------------------------------------- -# Helpers -# --------------------------------------------------------------------------- - -def _serialize_fieldchange(fc): - """Serialize a FieldChange for the API response.""" - result = serialize_fieldchange(fc) - result['uuid'] = fc.uuid - return result - - -# --------------------------------------------------------------------------- -# Field Changes List (unassigned) -# --------------------------------------------------------------------------- - -@blp.route('/field-changes') -class FieldChangeList(MethodView): - """List and create field changes.""" - - @require_scope('read') - @blp.arguments(FieldChangeListQuerySchema, location="query") - @blp.response(200, PaginatedFieldChangeResponseSchema) - def get(self, query_args, testsuite): - """List unassigned field changes (cursor-paginated, filterable). - - Returns field changes that have not been assigned to a regression. - """ - reject_unknown_params({'machine', 'test', 'metric', 'cursor', 'limit'}) - ts = g.ts - session = g.db_session - - # Unassigned = not linked to any regression via RegressionIndicator. - query = ( - session.query(ts.FieldChange) - .options( - joinedload(ts.FieldChange.test), - joinedload(ts.FieldChange.machine), - joinedload(ts.FieldChange.start_commit), - joinedload(ts.FieldChange.end_commit), - ) - .outerjoin(ts.RegressionIndicator) - .filter(ts.RegressionIndicator.id.is_(None)) - ) - - machine_name = query_args.get('machine') - if machine_name: - machine = lookup_machine(session, ts, machine_name) - query = query.filter( - ts.FieldChange.machine_id == machine.id) - - test_name = query_args.get('test') - if test_name: - test = lookup_test(session, ts, test_name) - query = query.filter( - ts.FieldChange.test_id == test.id) - - field_name = query_args.get('metric') - if field_name: - validate_metric_name(ts, field_name) - query = query.filter( - ts.FieldChange.field_name == field_name) - - cursor_str = query_args.get('cursor') - limit = query_args['limit'] - items, next_cursor = cursor_paginate( - query, ts.FieldChange.id, cursor_str, limit, descending=True) - - serialized = [_serialize_fieldchange(fc) for fc in items] - return jsonify(make_paginated_response(serialized, next_cursor)) - - @require_scope('submit') - @blp.arguments(FieldChangeCreateSchema) - @blp.response(201, FieldChangeResponseSchema) - def post(self, body, testsuite): - """Create a field change. - - References machine, test, metric, and commits by name. - """ - ts = g.ts - session = g.db_session - - machine = lookup_machine(session, ts, body['machine']) - test = lookup_test(session, ts, body['test']) - validate_metric_name(ts, body['metric']) - - start_commit = lookup_commit(session, ts, body['start_commit']) - end_commit = lookup_commit(session, ts, body['end_commit']) - - fc = ts.create_field_change( - session, machine, test, body['metric'], - start_commit, end_commit, - body['old_value'], body['new_value']) - - data = _serialize_fieldchange(fc) - resp = jsonify(data) - resp.status_code = 201 - return resp diff --git a/lnt/server/api/v5/endpoints/machines.py b/lnt/server/api/v5/endpoints/machines.py index f62a6ce2f..b73909dd0 100644 --- a/lnt/server/api/v5/endpoints/machines.py +++ b/lnt/server/api/v5/endpoints/machines.py @@ -210,11 +210,11 @@ def delete(self, testsuite, machine_name): session = g.db_session machine = lookup_machine(session, ts, machine_name) - # FieldChange.machine_id has no CASCADE, so delete them first. - # RegressionIndicator.field_change_id has ondelete=CASCADE, - # so those are auto-cleaned when the FieldChange is deleted. - session.query(ts.FieldChange).filter( - ts.FieldChange.machine_id == machine.id + # RegressionIndicator.machine_id has no CASCADE, so delete them + # before the machine. The Regression itself remains (it may have + # other indicators on different machines). + session.query(ts.RegressionIndicator).filter( + ts.RegressionIndicator.machine_id == machine.id ).delete(synchronize_session='fetch') ts.delete_machine(session, machine.id) diff --git a/lnt/server/api/v5/endpoints/regressions.py b/lnt/server/api/v5/endpoints/regressions.py index 7b0a67daa..ca1aed279 100644 --- a/lnt/server/api/v5/endpoints/regressions.py +++ b/lnt/server/api/v5/endpoints/regressions.py @@ -1,31 +1,26 @@ """Regression endpoints for the v5 API. -GET /api/v5/{ts}/regressions -- List -POST /api/v5/{ts}/regressions -- Create -GET /api/v5/{ts}/regressions/{uuid} -- Detail -PATCH /api/v5/{ts}/regressions/{uuid} -- Update -DELETE /api/v5/{ts}/regressions/{uuid} -- Delete -POST /api/v5/{ts}/regressions/{uuid}/merge -- Merge -POST /api/v5/{ts}/regressions/{uuid}/split -- Split -GET /api/v5/{ts}/regressions/{uuid}/indicators -- List indicators -POST /api/v5/{ts}/regressions/{uuid}/indicators -- Add indicator -DELETE /api/v5/{ts}/regressions/{uuid}/indicators/{fc_uuid} -- Remove indicator +GET /api/v5/{ts}/regressions -- List +POST /api/v5/{ts}/regressions -- Create +GET /api/v5/{ts}/regressions/{uuid} -- Detail +PATCH /api/v5/{ts}/regressions/{uuid} -- Update +DELETE /api/v5/{ts}/regressions/{uuid} -- Delete +POST /api/v5/{ts}/regressions/{uuid}/indicators -- Add indicators (batch) +DELETE /api/v5/{ts}/regressions/{uuid}/indicators -- Remove indicators (batch) """ from flask import g, jsonify, make_response from flask.views import MethodView from flask_smorest import Blueprint -from sqlalchemy.exc import IntegrityError -from sqlalchemy.orm import joinedload +from sqlalchemy.orm import joinedload, subqueryload from ..auth import require_scope from ..errors import abort_with_error, reject_unknown_params from ..helpers import ( - lookup_fieldchange, + lookup_commit, lookup_machine, lookup_regression, lookup_test, - serialize_fieldchange, validate_metric_name, ) from ..etag import add_etag_to_response @@ -35,15 +30,12 @@ ) from ..schemas.regressions import ( IndicatorAddSchema, + IndicatorRemoveSchema, IndicatorResponseSchema, - PaginatedIndicatorResponseSchema, PaginatedRegressionListSchema, RegressionCreateSchema, RegressionDetailSchema, - RegressionIndicatorsQuerySchema, RegressionListQuerySchema, - RegressionMergeSchema, - RegressionSplitSchema, RegressionUpdateSchema, STATE_TO_DB, state_to_api, @@ -54,7 +46,7 @@ 'Regressions', __name__, url_prefix='/api/v5/', - description='Triage performance regressions: create, merge, split, and manage indicators', + description='Triage performance regressions: create, update, delete, and manage indicators', ) @@ -62,67 +54,54 @@ # Helpers # --------------------------------------------------------------------------- -def _fc_load_branches(base, ts): - """Append FieldChange relationship loads to a joinedload base.""" - return [ - base.joinedload(ts.FieldChange.test), - base.joinedload(ts.FieldChange.machine), - base.joinedload(ts.FieldChange.start_commit), - base.joinedload(ts.FieldChange.end_commit), - ] - - -def _indicator_load_options(ts): - """Return joinedload options for eager-loading indicator relationships.""" - base = joinedload(ts.Regression.indicators) \ - .joinedload(ts.RegressionIndicator.field_change) - return _fc_load_branches(base, ts) - - -def _indicator_query_options(ts): - """Return joinedload options for a RegressionIndicator query.""" - base = joinedload(ts.RegressionIndicator.field_change) - return _fc_load_branches(base, ts) - - def _serialize_indicator(ri): """Serialize a RegressionIndicator into the API response dict.""" - fc = ri.field_change - if fc is None: - return None - result = serialize_fieldchange(fc) - result['field_change_uuid'] = fc.uuid - return result + return { + 'uuid': ri.uuid, + 'machine': ri.machine.name if ri.machine else None, + 'test': ri.test.name if ri.test else None, + 'metric': ri.metric, + } -def _serialize_regression_list(regression): - """Serialize a Regression for the list endpoint (no indicators).""" +def _serialize_regression_base(regression): + """Shared fields for both list and detail regression responses.""" return { 'uuid': regression.uuid, 'title': regression.title, 'bug': regression.bug, 'state': state_to_api(regression.state), + 'commit': (regression.commit_obj.commit + if regression.commit_obj else None), } -def _serialize_regression_detail(regression): - """Serialize a Regression for the detail endpoint (with indicators). +def _serialize_regression_list(regression): + """Serialize a Regression for the list endpoint. - Requires indicators to be eager-loaded via _indicator_load_options(). + Requires the regression to have indicators eagerly loaded (or + accessible) for computing machine_count and test_count. """ - serialized_indicators = [] + machines = set() + tests = set() for ri in regression.indicators: - ind = _serialize_indicator(ri) - if ind is not None: - serialized_indicators.append(ind) + machines.add(ri.machine_id) + tests.add(ri.test_id) - return { - 'uuid': regression.uuid, - 'title': regression.title, - 'bug': regression.bug, - 'state': state_to_api(regression.state), - 'indicators': serialized_indicators, - } + result = _serialize_regression_base(regression) + result['machine_count'] = len(machines) + result['test_count'] = len(tests) + return result + + +def _serialize_regression_detail(regression): + """Serialize a Regression for the detail endpoint (with indicators).""" + result = _serialize_regression_base(regression) + result['notes'] = regression.notes + result['indicators'] = [ + _serialize_indicator(ri) for ri in regression.indicators + ] + return result def _validate_state(state_str): @@ -139,15 +118,54 @@ def _validate_state(state_str): return db_state -def _lookup_regression_with_indicators(session, ts, regression_uuid): - """Look up a regression by UUID with eager-loaded indicators. +def _resolve_indicators(session, ts, indicator_dicts): + """Resolve indicator input dicts to DB-ready dicts. + + Each input dict has {machine, test, metric} (names). This function + looks up each entity and returns a list of dicts with + {machine_id, test_id, metric}. - Aborts with 404 if not found. + Aborts with 404 if any machine or test is not found, 400 if metric is + unknown. """ - reg = session.query(ts.Regression) \ - .options(*_indicator_load_options(ts)) \ - .filter(ts.Regression.uuid == regression_uuid) \ + resolved = [] + machine_cache = {} + test_cache = {} + for ind in indicator_dicts: + m_name = ind['machine'] + if m_name not in machine_cache: + machine_cache[m_name] = lookup_machine(session, ts, m_name) + t_name = ind['test'] + if t_name not in test_cache: + test_cache[t_name] = lookup_test(session, ts, t_name) + validate_metric_name(ts, ind['metric']) + resolved.append({ + 'machine_id': machine_cache[m_name].id, + 'test_id': test_cache[t_name].id, + 'metric': ind['metric'], + }) + return resolved + + +def _eager_load_regression(session, ts, regression_uuid): + """Look up a regression by UUID with eager-loaded relationships. + + Loads indicators with their machine and test relationships for + serialization. Aborts with 404 if not found. + """ + reg = ( + session.query(ts.Regression) + .populate_existing() + .options( + joinedload(ts.Regression.commit_obj), + subqueryload(ts.Regression.indicators) + .joinedload(ts.RegressionIndicator.machine), + subqueryload(ts.Regression.indicators) + .joinedload(ts.RegressionIndicator.test), + ) + .filter(ts.Regression.uuid == regression_uuid) .first() + ) if reg is None: abort_with_error(404, "Regression '%s' not found" % regression_uuid) return reg @@ -167,53 +185,68 @@ class RegressionList(MethodView): def get(self, query_args, testsuite): """List regressions (cursor-paginated, filterable).""" reject_unknown_params( - {'state', 'machine', 'test', 'metric', 'cursor', 'limit'}) + {'state', 'machine', 'test', 'metric', 'commit', + 'has_commit', 'cursor', 'limit'}) ts = g.ts session = g.db_session - query = session.query(ts.Regression) + query = session.query(ts.Regression).options( + joinedload(ts.Regression.commit_obj), + subqueryload(ts.Regression.indicators), + ) + # -- State filter -- state_values = query_args['state'] if state_values: db_states = [_validate_state(sv) for sv in state_values] query = query.filter(ts.Regression.state.in_(db_states)) + # -- Commit filters -- + commit_value = query_args.get('commit') + if commit_value: + commit_obj = lookup_commit(session, ts, commit_value) + query = query.filter( + ts.Regression.commit_id == commit_obj.id) + + has_commit = query_args.get('has_commit') + if has_commit is True: + query = query.filter( + ts.Regression.commit_id.isnot(None)) + elif has_commit is False: + query = query.filter( + ts.Regression.commit_id.is_(None)) + + # -- Machine / test / metric filters (via indicator JOIN) -- machine_name = query_args.get('machine') test_name = query_args.get('test') - field_name = query_args.get('metric') + metric_name = query_args.get('metric') - # Validate entity names before building JOINs (404/400 on bad names) machine = None if machine_name: machine = lookup_machine(session, ts, machine_name) test = None if test_name: test = lookup_test(session, ts, test_name) - if field_name: - validate_metric_name(ts, field_name) + if metric_name: + validate_metric_name(ts, metric_name) - if machine or test or field_name: + if machine or test or metric_name: query = query.join( ts.RegressionIndicator, ts.RegressionIndicator.regression_id == ts.Regression.id - ).join( - ts.FieldChange, - ts.RegressionIndicator.field_change_id == ts.FieldChange.id ) if machine: query = query.filter( - ts.FieldChange.machine_id == machine.id) - + ts.RegressionIndicator.machine_id == machine.id) if test: query = query.filter( - ts.FieldChange.test_id == test.id) - - if field_name: + ts.RegressionIndicator.test_id == test.id) + if metric_name: query = query.filter( - ts.FieldChange.field_name == field_name) + ts.RegressionIndicator.metric == metric_name) - if machine or test or field_name: + if machine or test or metric_name: query = query.distinct() cursor_str = query_args.get('cursor') @@ -228,26 +261,35 @@ def get(self, query_args, testsuite): @blp.arguments(RegressionCreateSchema) @blp.response(201, RegressionDetailSchema) def post(self, body, testsuite): - """Create a new regression from field changes.""" + """Create a new regression.""" ts = g.ts session = g.db_session - fc_uuids = body['field_change_uuids'] - field_changes = [lookup_fieldchange(session, ts, u) for u in fc_uuids] - state_str = body.get('state') or 'detected' db_state = _validate_state(state_str) - title = body.get('title') or 'Regression of %d benchmarks' % len( - field_changes) - bug = body.get('bug') or '' + # Resolve commit by value (optional) + commit_obj = None + commit_value = body.get('commit') + if commit_value: + commit_obj = lookup_commit(session, ts, commit_value) + + # Resolve indicators (optional) + indicator_dicts = body.get('indicators') or [] + resolved = _resolve_indicators(session, ts, indicator_dicts) + + title = body.get('title') or ( + 'Regression of %d benchmarks' % len(resolved) + if resolved else 'New regression') + bug = body.get('bug') + notes = body.get('notes') regression = ts.create_regression( - session, title, [fc.id for fc in field_changes], - bug=bug, state=db_state) + session, title, resolved, + bug=bug, notes=notes, commit=commit_obj, state=db_state) - # Reload with eager-loaded indicators for serialization - regression = _lookup_regression_with_indicators( + # Reload with eager-loaded relationships for serialization + regression = _eager_load_regression( session, ts, regression.uuid) result = _serialize_regression_detail(regression) @@ -271,8 +313,7 @@ def get(self, testsuite, regression_uuid): reject_unknown_params(set()) ts = g.ts session = g.db_session - regression = _lookup_regression_with_indicators( - session, ts, regression_uuid) + regression = _eager_load_regression(session, ts, regression_uuid) data = _serialize_regression_detail(regression) return add_etag_to_response(jsonify(data), data) @@ -280,21 +321,38 @@ def get(self, testsuite, regression_uuid): @blp.arguments(RegressionUpdateSchema) @blp.response(200, RegressionDetailSchema) def patch(self, body, testsuite, regression_uuid): - """Update regression title, bug URL, and/or state.""" + """Update regression title, bug, notes, state, and/or commit.""" ts = g.ts session = g.db_session - regression = _lookup_regression_with_indicators( - session, ts, regression_uuid) + regression = lookup_regression(session, ts, regression_uuid) + + # Fields present in body are updated; None values clear the field. + # Fields absent from body are left unchanged. + kwargs = {} + + if 'title' in body: + kwargs['title'] = body['title'] + + if 'bug' in body: + kwargs['bug'] = body['bug'] + + if 'notes' in body: + kwargs['notes'] = body['notes'] - title = body.get('title') - bug = body.get('bug') - state = None if 'state' in body: - state = _validate_state(body['state']) + kwargs['state'] = _validate_state(body['state']) + + if 'commit' in body: + commit_value = body['commit'] + if commit_value is None: + kwargs['commit'] = None # clear + else: + kwargs['commit'] = lookup_commit(session, ts, commit_value) - ts.update_regression( - session, regression, title=title, bug=bug, state=state) + ts.update_regression(session, regression, **kwargs) + # Reload for serialization (relationships may have changed) + regression = _eager_load_regression(session, ts, regression_uuid) return jsonify(_serialize_regression_detail(regression)) @require_scope('triage') @@ -309,212 +367,55 @@ def delete(self, testsuite, regression_uuid): # --------------------------------------------------------------------------- -# Merge +# Indicators # --------------------------------------------------------------------------- -@blp.route('/regressions//merge') -class RegressionMerge(MethodView): - """Merge source regressions into the target regression.""" +@blp.route('/regressions//indicators') +class RegressionIndicators(MethodView): + """Add and remove indicators for a regression (batch operations).""" @require_scope('triage') - @blp.arguments(RegressionMergeSchema) + @blp.arguments(IndicatorAddSchema) @blp.response(200, RegressionDetailSchema) def post(self, body, testsuite, regression_uuid): - """Merge source regressions into this one. + """Add indicators to a regression (batch). - The target absorbs all indicators from the source regressions. - Sources are marked as ignored. Duplicate indicators are - deduplicated. + Duplicates (same regression+machine+test+metric) are silently + ignored. """ ts = g.ts session = g.db_session - target = lookup_regression(session, ts, regression_uuid) - - source_uuids = body['source_regression_uuids'] - - for suuid in source_uuids: - if suuid == regression_uuid: - abort_with_error( - 400, "Cannot merge a regression into itself") - - # Collect existing indicator field_change_ids for deduplication - existing_fc_ids = set() - target_indicators = session.query(ts.RegressionIndicator).filter( - ts.RegressionIndicator.regression_id == target.id - ).all() - for ri in target_indicators: - existing_fc_ids.add(ri.field_change_id) - - sources = [lookup_regression(session, ts, u) for u in source_uuids] - - for source in sources: - source_indicators = session.query(ts.RegressionIndicator).filter( - ts.RegressionIndicator.regression_id == source.id - ).all() - - for ri in source_indicators: - if ri.field_change_id not in existing_fc_ids: - ri.regression_id = target.id - existing_fc_ids.add(ri.field_change_id) - else: - session.delete(ri) + regression = lookup_regression(session, ts, regression_uuid) - ts.update_regression( - session, source, state=STATE_TO_DB['ignored']) + indicator_dicts = body['indicators'] + resolved = _resolve_indicators(session, ts, indicator_dicts) - session.flush() + ts.add_regression_indicators_batch(session, regression, resolved) - # Reload with eager-loaded indicators for serialization - target = _lookup_regression_with_indicators( + # Reload and return full detail + regression = _eager_load_regression( session, ts, regression_uuid) - return jsonify(_serialize_regression_detail(target)) - - -# --------------------------------------------------------------------------- -# Split -# --------------------------------------------------------------------------- - -@blp.route('/regressions//split') -class RegressionSplit(MethodView): - """Split field changes from a regression into a new regression.""" + return jsonify(_serialize_regression_detail(regression)) @require_scope('triage') - @blp.arguments(RegressionSplitSchema) - @blp.response(201, RegressionDetailSchema) - def post(self, body, testsuite, regression_uuid): - """Split specified field changes into a new regression. + @blp.arguments(IndicatorRemoveSchema) + @blp.response(200, RegressionDetailSchema) + def delete(self, body, testsuite, regression_uuid): + """Remove indicators from a regression (batch, by UUID). - At least one indicator must remain in the source regression. + Unknown UUIDs are silently ignored. """ ts = g.ts session = g.db_session - source = lookup_regression(session, ts, regression_uuid) - - fc_uuids = body['field_change_uuids'] - - all_indicators = session.query(ts.RegressionIndicator).filter( - ts.RegressionIndicator.regression_id == source.id - ).all() - - fc_id_to_ri = {ri.field_change_id: ri for ri in all_indicators} - - indicators_to_move = [] - for fc_uuid in fc_uuids: - fc = lookup_fieldchange(session, ts, fc_uuid) - ri = fc_id_to_ri.get(fc.id) - if ri is None: - abort_with_error( - 400, - "Field change '%s' is not an indicator of regression " - "'%s'" % (fc_uuid, regression_uuid)) - indicators_to_move.append(ri) - - if len(indicators_to_move) >= len(all_indicators): - abort_with_error( - 400, - "Cannot split all indicators from a regression. " - "At least one indicator must remain.") - - # Create new regression (empty indicators, then move them) - new_regression = ts.create_regression( - session, source.title, [], bug=source.bug or '', - state=source.state) - - for ri in indicators_to_move: - ri.regression_id = new_regression.id - - session.flush() - - # Reload with eager-loaded indicators for serialization - new_regression = _lookup_regression_with_indicators( - session, ts, new_regression.uuid) - return jsonify( - _serialize_regression_detail(new_regression)), 201 - - -# --------------------------------------------------------------------------- -# Indicators -# --------------------------------------------------------------------------- - -@blp.route('/regressions//indicators') -class RegressionIndicators(MethodView): - """List and add indicators for a regression.""" - - @require_scope('read') - @blp.arguments(RegressionIndicatorsQuerySchema, location="query") - @blp.response(200, PaginatedIndicatorResponseSchema) - def get(self, query_args, testsuite, regression_uuid): - """List indicators for a regression (cursor-paginated).""" - reject_unknown_params({'cursor', 'limit'}) - ts = g.ts - session = g.db_session regression = lookup_regression(session, ts, regression_uuid) - query = session.query(ts.RegressionIndicator) \ - .options(*_indicator_query_options(ts)) \ - .filter( - ts.RegressionIndicator.regression_id == regression.id) - - cursor_str = query_args.get('cursor') - limit = query_args['limit'] - items, next_cursor = cursor_paginate( - query, ts.RegressionIndicator.id, cursor_str, limit) - - serialized = [] - for ri in items: - ind = _serialize_indicator(ri) - if ind is not None: - serialized.append(ind) - - return jsonify(make_paginated_response(serialized, next_cursor)) - - @require_scope('triage') - @blp.arguments(IndicatorAddSchema) - @blp.response(201, IndicatorResponseSchema) - def post(self, body, testsuite, regression_uuid): - """Add a field change as an indicator to this regression.""" - ts = g.ts - session = g.db_session - regression = lookup_regression(session, ts, regression_uuid) - - fc_uuid = body['field_change_uuid'] - fc = lookup_fieldchange(session, ts, fc_uuid) - - try: - ri = ts.add_regression_indicator(session, regression, fc) - except IntegrityError: - session.rollback() - abort_with_error( - 409, - "Field change '%s' is already an indicator of this " - "regression" % fc_uuid) - - result = _serialize_indicator(ri) - resp = jsonify(result) - resp.status_code = 201 - return resp - - -@blp.route( - '/regressions//indicators/') -class RegressionIndicatorRemove(MethodView): - """Remove a field change indicator from a regression.""" - - @require_scope('triage') - @blp.response(204) - def delete(self, testsuite, regression_uuid, fc_uuid): - """Remove a field change indicator from a regression.""" - ts = g.ts - session = g.db_session - regression = lookup_regression(session, ts, regression_uuid) - fc = lookup_fieldchange(session, ts, fc_uuid) - - removed = ts.remove_regression_indicator( - session, regression.id, fc.id) - if not removed: - abort_with_error( - 404, - "Field change '%s' is not an indicator of regression " - "'%s'" % (fc_uuid, regression_uuid)) + session.query(ts.RegressionIndicator).filter( + ts.RegressionIndicator.regression_id == regression.id, + ts.RegressionIndicator.uuid.in_(body['indicator_uuids']), + ).delete(synchronize_session='fetch') + session.flush() - return make_response('', 204) + # Reload and return full detail + regression = _eager_load_regression( + session, ts, regression_uuid) + return jsonify(_serialize_regression_detail(regression)) diff --git a/lnt/server/api/v5/endpoints/runs.py b/lnt/server/api/v5/endpoints/runs.py index 5a5dd4dc6..c272469f3 100644 --- a/lnt/server/api/v5/endpoints/runs.py +++ b/lnt/server/api/v5/endpoints/runs.py @@ -107,8 +107,8 @@ def post(self, query_args, testsuite): """Submit a new run. Accepts the v5 JSON report format (format_version '5'). - Regression detection is always skipped; create field changes - separately via POST /field-changes. + Regression detection is external; create regressions + separately via POST /regressions. """ reject_unknown_params({'on_machine_conflict'}) ts = g.ts diff --git a/lnt/server/api/v5/endpoints/test_suites.py b/lnt/server/api/v5/endpoints/test_suites.py index fb2e9c63f..0f3857c95 100644 --- a/lnt/server/api/v5/endpoints/test_suites.py +++ b/lnt/server/api/v5/endpoints/test_suites.py @@ -42,7 +42,6 @@ def _suite_links(name): 'runs': prefix + '/runs', 'tests': prefix + '/tests', 'regressions': prefix + '/regressions', - 'field_changes': prefix + '/field-changes', 'query': prefix + '/query', } diff --git a/lnt/server/api/v5/helpers.py b/lnt/server/api/v5/helpers.py index c1e77ef48..efd53b64f 100644 --- a/lnt/server/api/v5/helpers.py +++ b/lnt/server/api/v5/helpers.py @@ -75,14 +75,6 @@ def lookup_run_by_uuid(session, ts, run_uuid): return run -def lookup_fieldchange(session, ts, fc_uuid): - """Look up a FieldChange by UUID. Aborts with 404 if not found.""" - fc = ts.get_field_change(session, uuid=fc_uuid) - if fc is None: - abort_with_error(404, "Field change '%s' not found" % fc_uuid) - return fc - - def lookup_commit(session, ts, commit_id): """Look up a Commit by its identity string (e.g. git SHA). @@ -133,22 +125,3 @@ def serialize_run(run, ts): 'submitted_at': submitted_at, 'run_parameters': dict(run.run_parameters) if run.run_parameters else {}, } - - -def serialize_fieldchange(fc): - """Serialize the common fields of a FieldChange for API responses. - - Returns a dict with test, machine, metric, old_value, new_value, - start_commit, and end_commit. Callers should add an identifier key - (``uuid`` or ``field_change_uuid``) to the result before returning - it to the client. - """ - return { - 'test': fc.test.name if fc.test else None, - 'machine': fc.machine.name if fc.machine else None, - 'metric': fc.field_name, - 'old_value': fc.old_value, - 'new_value': fc.new_value, - 'start_commit': fc.start_commit.commit if fc.start_commit else None, - 'end_commit': fc.end_commit.commit if fc.end_commit else None, - } diff --git a/lnt/server/api/v5/schemas/common.py b/lnt/server/api/v5/schemas/common.py index c709c60f7..d6605a384 100644 --- a/lnt/server/api/v5/schemas/common.py +++ b/lnt/server/api/v5/schemas/common.py @@ -55,7 +55,6 @@ class TestSuiteLinksSchema(BaseSchema): runs = ma.fields.String() tests = ma.fields.String() regressions = ma.fields.String() - field_changes = ma.fields.String() query = ma.fields.String() diff --git a/lnt/server/api/v5/schemas/regressions.py b/lnt/server/api/v5/schemas/regressions.py index 54b8eee11..a083a17ff 100644 --- a/lnt/server/api/v5/schemas/regressions.py +++ b/lnt/server/api/v5/schemas/regressions.py @@ -1,5 +1,5 @@ -"""Marshmallow schemas for regression, indicator, and field change -request/response in the v5 API. +"""Marshmallow schemas for regression and indicator request/response +in the v5 API. """ import logging @@ -13,17 +13,15 @@ # --------------------------------------------------------------------------- -# State mapping: API string <-> DB integer (v5 values: 0-6) +# State mapping: API string <-> DB integer (v5 values: 0-4) # --------------------------------------------------------------------------- STATE_TO_DB = { 'detected': 0, - 'staged': 1, - 'active': 2, - 'not_to_be_fixed': 3, - 'ignored': 4, - 'fixed': 5, - 'detected_fixed': 6, + 'active': 1, + 'not_to_be_fixed': 2, + 'fixed': 3, + 'false_positive': 4, } DB_TO_STATE = {v: k for k, v in STATE_TO_DB.items()} @@ -54,112 +52,62 @@ def state_to_db(api_string): # --------------------------------------------------------------------------- -# Indicator / field change schemas +# Indicator schemas # --------------------------------------------------------------------------- class IndicatorResponseSchema(BaseSchema): - """Schema for a single regression indicator (embedded in regression - detail or in the indicators list endpoint). - """ - field_change_uuid = ma.fields.String( - required=True, - metadata={'description': 'UUID of the field change'}, - ) - test = ma.fields.String( + """Schema for a single regression indicator.""" + uuid = ma.fields.String( required=True, - metadata={'description': 'Name of the test'}, + metadata={'description': 'Indicator UUID'}, ) machine = ma.fields.String( required=True, metadata={'description': 'Name of the machine'}, ) - metric = ma.fields.String( - required=True, - metadata={'description': 'Metric name (as defined in the test suite schema)'}, - ) - old_value = ma.fields.Float( - allow_none=True, - metadata={'description': 'Previous value'}, - ) - new_value = ma.fields.Float( - allow_none=True, - metadata={'description': 'New value'}, - ) - start_commit = ma.fields.String( - allow_none=True, - metadata={'description': 'Start commit identity string'}, - ) - end_commit = ma.fields.String( - allow_none=True, - metadata={'description': 'End commit identity string'}, - ) - - -class FieldChangeResponseSchema(BaseSchema): - """Schema for an unassigned field change in the field-changes list.""" - uuid = ma.fields.String( - required=True, - metadata={'description': 'Field change UUID'}, - ) test = ma.fields.String( required=True, metadata={'description': 'Name of the test'}, ) - machine = ma.fields.String( - required=True, - metadata={'description': 'Name of the machine'}, - ) metric = ma.fields.String( required=True, - metadata={'description': 'Metric name (as defined in the test suite schema)'}, - ) - old_value = ma.fields.Float( - allow_none=True, - metadata={'description': 'Previous value'}, - ) - new_value = ma.fields.Float( - allow_none=True, - metadata={'description': 'New value'}, - ) - start_commit = ma.fields.String( - allow_none=True, - metadata={'description': 'Start commit identity string'}, - ) - end_commit = ma.fields.String( - allow_none=True, - metadata={'description': 'End commit identity string'}, + metadata={'description': 'Metric name'}, ) -class FieldChangeCreateSchema(BaseSchema): - """Schema for POST /field-changes request body.""" +class IndicatorInputSchema(BaseSchema): + """Schema for a single indicator input ({machine, test, metric}).""" machine = ma.fields.String( required=True, - metadata={'description': 'Name of the machine'}, + metadata={'description': 'Machine name'}, ) test = ma.fields.String( required=True, - metadata={'description': 'Name of the test'}, + metadata={'description': 'Test name'}, ) metric = ma.fields.String( required=True, - metadata={'description': 'Metric name (as defined in the test suite schema)'}, - ) - old_value = ma.fields.Float( - required=True, - metadata={'description': 'Previous value'}, + metadata={'description': 'Metric name'}, ) - new_value = ma.fields.Float( - required=True, - metadata={'description': 'New value'}, - ) - start_commit = ma.fields.String( + + +class IndicatorAddSchema(BaseSchema): + """Schema for POST /regressions/{uuid}/indicators request body.""" + indicators = ma.fields.List( + ma.fields.Nested(IndicatorInputSchema), required=True, - metadata={'description': 'Commit identity string for start of change'}, + validate=ma.validate.Length(min=1), + metadata={'description': 'List of {machine, test, metric} indicators to add'}, ) - end_commit = ma.fields.String( + + +class IndicatorRemoveSchema(BaseSchema): + """Schema for DELETE /regressions/{uuid}/indicators request body.""" + indicator_uuids = ma.fields.List( + ma.fields.String(), required=True, - metadata={'description': 'Commit identity string for end of change'}, + validate=ma.validate.Length(min=1), + metadata={'description': 'UUIDs of indicators to remove'}, ) @@ -169,12 +117,6 @@ class FieldChangeCreateSchema(BaseSchema): class RegressionCreateSchema(BaseSchema): """Schema for POST /regressions request body.""" - field_change_uuids = ma.fields.List( - ma.fields.String(), - required=True, - validate=ma.validate.Length(min=1), - metadata={'description': 'List of field change UUIDs to include'}, - ) title = ma.fields.String( load_default=None, metadata={'description': 'Optional title (auto-generated if omitted)'}, @@ -183,53 +125,52 @@ class RegressionCreateSchema(BaseSchema): load_default=None, metadata={'description': 'Optional bug URL'}, ) + notes = ma.fields.String( + load_default=None, + metadata={'description': 'Optional investigation notes'}, + ) state = ma.fields.String( load_default=None, validate=ma.validate.OneOf(VALID_STATES), metadata={'description': 'Optional initial state (default: detected)', 'enum': VALID_STATES}, ) + commit = ma.fields.String( + load_default=None, + metadata={'description': 'Optional suspected introduction commit (resolved by value)'}, + ) + indicators = ma.fields.List( + ma.fields.Nested(IndicatorInputSchema), + load_default=[], + metadata={'description': 'Optional list of {machine, test, metric} indicators'}, + ) class RegressionUpdateSchema(BaseSchema): - """Schema for PATCH /regressions/{uuid} request body.""" + """Schema for PATCH /regressions/{uuid} request body. + + Fields must NOT have ``load_default`` — the PATCH handler uses + ``'key' in body`` to distinguish absent fields (leave unchanged) from + fields sent as ``null`` (clear the value). + """ title = ma.fields.String( metadata={'description': 'New title'}, ) bug = ma.fields.String( - metadata={'description': 'New bug URL'}, + allow_none=True, + metadata={'description': 'New bug URL (null to clear)'}, + ) + notes = ma.fields.String( + allow_none=True, + metadata={'description': 'New notes (null to clear)'}, ) state = ma.fields.String( validate=ma.validate.OneOf(VALID_STATES), metadata={'description': 'New state', 'enum': VALID_STATES}, ) - - -class RegressionMergeSchema(BaseSchema): - """Schema for POST /regressions/{uuid}/merge request body.""" - source_regression_uuids = ma.fields.List( - ma.fields.String(), - required=True, - validate=ma.validate.Length(min=1), - metadata={'description': 'UUIDs of regressions to merge into this one'}, - ) - - -class RegressionSplitSchema(BaseSchema): - """Schema for POST /regressions/{uuid}/split request body.""" - field_change_uuids = ma.fields.List( - ma.fields.String(), - required=True, - validate=ma.validate.Length(min=1), - metadata={'description': 'Field change UUIDs to split into a new regression'}, - ) - - -class IndicatorAddSchema(BaseSchema): - """Schema for POST /regressions/{uuid}/indicators request body.""" - field_change_uuid = ma.fields.String( - required=True, - metadata={'description': 'UUID of the field change to add'}, + commit = ma.fields.String( + allow_none=True, + metadata={'description': 'Suspected introduction commit (null to clear)'}, ) @@ -238,9 +179,7 @@ class IndicatorAddSchema(BaseSchema): # --------------------------------------------------------------------------- class RegressionListItemSchema(BaseSchema): - """Schema for a regression in list responses (without embedded - indicators). - """ + """Schema for a regression in list responses.""" uuid = ma.fields.String(required=True) title = ma.fields.String(allow_none=True) bug = ma.fields.String(allow_none=True) @@ -248,19 +187,35 @@ class RegressionListItemSchema(BaseSchema): required=True, metadata={'description': 'Regression state', 'enum': VALID_STATES}, ) + commit = ma.fields.String( + allow_none=True, + metadata={'description': 'Suspected introduction commit (identity string)'}, + ) + machine_count = ma.fields.Integer( + metadata={'description': 'Number of distinct machines across indicators'}, + ) + test_count = ma.fields.Integer( + metadata={'description': 'Number of distinct tests across indicators'}, + ) class RegressionDetailSchema(BaseSchema): - """Schema for a single regression detail response (with embedded - indicators). - """ + """Schema for a single regression detail response.""" uuid = ma.fields.String(required=True) title = ma.fields.String(allow_none=True) bug = ma.fields.String(allow_none=True) + notes = ma.fields.String( + allow_none=True, + metadata={'description': 'Investigation notes'}, + ) state = ma.fields.String( required=True, metadata={'description': 'Regression state', 'enum': VALID_STATES}, ) + commit = ma.fields.String( + allow_none=True, + metadata={'description': 'Suspected introduction commit (identity string)'}, + ) indicators = ma.fields.List( ma.fields.Nested(IndicatorResponseSchema), metadata={'description': 'Embedded list of regression indicators'}, @@ -272,20 +227,10 @@ class RegressionDetailSchema(BaseSchema): # --------------------------------------------------------------------------- class PaginatedRegressionListSchema(PaginatedResponseSchema): - """Paginated list of regressions (without embedded indicators).""" + """Paginated list of regressions.""" items = ma.fields.List(ma.fields.Nested(RegressionListItemSchema)) -class PaginatedIndicatorResponseSchema(PaginatedResponseSchema): - """Paginated list of regression indicators.""" - items = ma.fields.List(ma.fields.Nested(IndicatorResponseSchema)) - - -class PaginatedFieldChangeResponseSchema(PaginatedResponseSchema): - """Paginated list of unassigned field changes.""" - items = ma.fields.List(ma.fields.Nested(FieldChangeResponseSchema)) - - # --------------------------------------------------------------------------- # Query parameter schemas # --------------------------------------------------------------------------- @@ -295,7 +240,7 @@ class RegressionListQuerySchema(CursorPaginationQuerySchema): state = webargs_fields.DelimitedList( ma.fields.String(), load_default=[], - metadata={'description': 'Filter by state (comma-separated, e.g. active,detected)'}, + metadata={'description': 'Filter by state (comma-separated)'}, ) machine = ma.fields.String( load_default=None, @@ -309,24 +254,11 @@ class RegressionListQuerySchema(CursorPaginationQuerySchema): load_default=None, metadata={'description': 'Filter by metric name'}, ) - - -class RegressionIndicatorsQuerySchema(CursorPaginationQuerySchema): - """Query parameters for GET /regressions/{uuid}/indicators.""" - pass - - -class FieldChangeListQuerySchema(CursorPaginationQuerySchema): - """Query parameters for GET /field-changes.""" - machine = ma.fields.String( + commit = ma.fields.String( load_default=None, - metadata={'description': 'Filter by machine name'}, + metadata={'description': 'Filter by commit (regressions whose commit_id matches)'}, ) - test = ma.fields.String( - load_default=None, - metadata={'description': 'Filter by test name'}, - ) - metric = ma.fields.String( + has_commit = ma.fields.Boolean( load_default=None, - metadata={'description': 'Filter by metric name'}, + metadata={'description': 'Filter: true = has commit, false = no commit'}, ) diff --git a/tests/server/api/v5/test_commits.py b/tests/server/api/v5/test_commits.py index 99f2a8935..e81e3b676 100644 --- a/tests/server/api/v5/test_commits.py +++ b/tests/server/api/v5/test_commits.py @@ -526,31 +526,32 @@ def test_delete_nonexistent_404(self): ) self.assertEqual(resp.status_code, 404) - def test_delete_with_fieldchange_409(self): - """Delete a commit referenced by a FieldChange returns 409.""" - from v5_test_helpers import ( - create_machine, create_test, create_fieldchange, - ) + def test_delete_with_regression_409(self): + """Delete a commit referenced by a Regression returns 409.""" + from v5_test_helpers import create_machine, create_test db = self.app.instance.get_database("default") session = db.make_session() ts = db.testsuite[TS] - c1 = create_commit(session, ts, - commit=f'fc-start-{uuid.uuid4().hex[:8]}') - c2 = create_commit(session, ts, - commit=f'fc-end-{uuid.uuid4().hex[:8]}') - c1_commit = c1.commit # save before closing session - machine = create_machine( - session, ts, name=f'fc-del-{uuid.uuid4().hex[:8]}') - test = create_test( - session, ts, name=f'fc-del/test/{uuid.uuid4().hex[:8]}') - create_fieldchange(session, ts, c1, c2, machine, test, - 'execution_time') + c = create_commit(session, ts, + commit=f'reg-ref-{uuid.uuid4().hex[:8]}') + c_commit = c.commit + m = create_machine(session, ts, + name=f'reg-del-{uuid.uuid4().hex[:8]}') + t = create_test(session, ts, + name=f'reg-del/test/{uuid.uuid4().hex[:8]}') + + from v5_test_helpers import create_regression + create_regression( + session, ts, + indicators=[{'machine_id': m.id, 'test_id': t.id, + 'metric': 'execution_time'}], + commit=c) session.commit() session.close() resp = self.client.delete( - PREFIX + f'/commits/{c1_commit}', + PREFIX + f'/commits/{c_commit}', headers=admin_headers(), ) self.assertEqual(resp.status_code, 409) diff --git a/tests/server/api/v5/test_discovery.py b/tests/server/api/v5/test_discovery.py index 7cf33a8eb..3ae8e6d6e 100644 --- a/tests/server/api/v5/test_discovery.py +++ b/tests/server/api/v5/test_discovery.py @@ -46,7 +46,7 @@ def test_discovery_suite_links_are_complete(self): links = suite['links'] expected_keys = { 'machines', 'commits', 'runs', 'tests', - 'regressions', 'field_changes', 'query' + 'regressions', 'query' } self.assertEqual(set(links.keys()), expected_keys) diff --git a/tests/server/api/v5/test_field_changes.py b/tests/server/api/v5/test_field_changes.py deleted file mode 100644 index 7cdce879c..000000000 --- a/tests/server/api/v5/test_field_changes.py +++ /dev/null @@ -1,607 +0,0 @@ -# Tests for the v5 field change triage endpoints. -# -# RUN: rm -rf %t.instance %t.pg.log -# RUN: %{utils}/with_postgres.sh %t.pg.log \ -# RUN: %{utils}/with_temporary_instance.py --db-version 5.0 %t.instance \ -# RUN: -- python %s %t.instance -# END. - -import json -import sys -import os -import unittest -import uuid - -sys.path.insert(0, os.path.dirname(__file__)) -from v5_test_helpers import ( - create_app, create_client, make_scoped_headers, admin_headers, - collect_all_pages, submit_run, submit_fieldchange, - create_machine, create_commit, create_test, - create_fieldchange, create_regression, -) - - -def _submit_headers(app): - return make_scoped_headers(app, 'submit') - - -TS = 'nts' -PREFIX = f'/api/v5/{TS}' - - -def _create_fieldchange_fixture(client, app, prefix='fc', - old_value=10.0, new_value=20.0): - """Create a machine, two runs, and a field change via the API. - - Returns the field change UUID. - """ - tag = uuid.uuid4().hex[:8] - machine = f'{prefix}-m-{tag}' - rev1 = f'{prefix}-o1-{tag}' - rev2 = f'{prefix}-o2-{tag}' - test = f'{prefix}/test/{tag}' - submit_run(client, machine, rev1, - [{'name': test, 'execution_time': [1.0]}]) - submit_run(client, machine, rev2, - [{'name': test, 'execution_time': [2.0]}]) - fc = submit_fieldchange(client, app, machine, test, - 'execution_time', rev1, rev2, - old_value=old_value, new_value=new_value) - return fc['uuid'] - - -def _create_unassigned_fieldchange(client, app): - """Create an unassigned field change.""" - return _create_fieldchange_fixture(client, app) - - -def _create_assigned_fieldchange(app): - """Create a field change assigned to a regression via direct DB helpers. - - Uses direct DB helpers because the regressions endpoint is not yet - rewritten. - """ - tag = uuid.uuid4().hex[:8] - db = app.instance.get_database("default") - session = db.make_session() - ts = db.testsuite[TS] - - machine = create_machine(session, ts, name=f'fc-assigned-m-{tag}') - test = create_test(session, ts, name=f'fc-assigned/test/{tag}') - c1 = create_commit(session, ts, commit=f'fc-assigned-c1-{tag}') - c2 = create_commit(session, ts, commit=f'fc-assigned-c2-{tag}') - - fc = create_fieldchange(session, ts, c1, c2, machine, test, - 'execution_time', old_value=1.0, new_value=2.0) - create_regression(session, ts, field_changes=[fc]) - session.commit() - fc_uuid = fc.uuid - session.close() - return fc_uuid - - -# ========================================================================== -# Field Change List (Unassigned) Tests -# ========================================================================== - -class TestFieldChangeList(unittest.TestCase): - @classmethod - def setUpClass(cls): - super().setUpClass() - cls.app = create_app(sys.argv[1]) - cls.client = create_client(cls.app) - - def test_list_returns_200(self): - resp = self.client.get(PREFIX + '/field-changes') - self.assertEqual(resp.status_code, 200) - data = resp.get_json() - self.assertIn('items', data) - self.assertIsInstance(data['items'], list) - - def test_list_has_pagination_envelope(self): - resp = self.client.get(PREFIX + '/field-changes') - data = resp.get_json() - self.assertIn('cursor', data) - self.assertIn('next', data['cursor']) - self.assertIn('previous', data['cursor']) - - def test_list_contains_unassigned_fc(self): - fc_uuid = _create_unassigned_fieldchange(self.client, self.app) - resp = self.client.get(PREFIX + '/field-changes') - data = resp.get_json() - uuids = [fc['uuid'] for fc in data['items']] - self.assertIn(fc_uuid, uuids) - - def test_list_excludes_assigned_fc(self): - """Field changes with a RegressionIndicator should NOT appear.""" - assigned_uuid = _create_assigned_fieldchange(self.app) - resp = self.client.get(PREFIX + '/field-changes') - data = resp.get_json() - uuids = [fc['uuid'] for fc in data['items']] - self.assertNotIn(assigned_uuid, uuids) - - def test_list_item_has_expected_fields(self): - _create_unassigned_fieldchange(self.client, self.app) - resp = self.client.get(PREFIX + '/field-changes') - data = resp.get_json() - if data['items']: - item = data['items'][0] - self.assertIn('uuid', item) - self.assertIn('test', item) - self.assertIn('machine', item) - self.assertIn('metric', item) - self.assertIn('old_value', item) - self.assertIn('new_value', item) - self.assertIn('start_commit', item) - self.assertIn('end_commit', item) - - def test_list_filter_by_machine(self): - """Filter unassigned field changes by machine name.""" - unique = uuid.uuid4().hex[:8] - machine_name = f'fc-filter-m-{unique}' - rev1 = f'fc-fm-o1-{uuid.uuid4().hex[:8]}' - rev2 = f'fc-fm-o2-{uuid.uuid4().hex[:8]}' - test_name = f'fc/filter-m/{uuid.uuid4().hex[:8]}' - submit_run(self.client, machine_name, rev1, - [{'name': test_name, 'execution_time': [1.0]}]) - submit_run(self.client, machine_name, rev2, - [{'name': test_name, 'execution_time': [2.0]}]) - fc = submit_fieldchange(self.client, self.app, machine_name, - test_name, 'execution_time', rev1, rev2) - fc_uuid = fc['uuid'] - - resp = self.client.get( - PREFIX + f'/field-changes?machine={machine_name}') - self.assertEqual(resp.status_code, 200) - data = resp.get_json() - for item in data['items']: - self.assertEqual(item['machine'], machine_name) - uuids = [item['uuid'] for item in data['items']] - self.assertIn(fc_uuid, uuids) - - def test_list_filter_by_test(self): - """Filter unassigned field changes by test name.""" - unique = uuid.uuid4().hex[:8] - test_name = f'fc/filter-t/{unique}' - machine_name = f'fc-ft-m-{uuid.uuid4().hex[:8]}' - rev1 = f'fc-ft-o1-{uuid.uuid4().hex[:8]}' - rev2 = f'fc-ft-o2-{uuid.uuid4().hex[:8]}' - submit_run(self.client, machine_name, rev1, - [{'name': test_name, 'execution_time': [1.0]}]) - submit_run(self.client, machine_name, rev2, - [{'name': test_name, 'execution_time': [2.0]}]) - fc = submit_fieldchange(self.client, self.app, machine_name, - test_name, 'execution_time', rev1, rev2) - fc_uuid = fc['uuid'] - - resp = self.client.get( - PREFIX + f'/field-changes?test={test_name}') - self.assertEqual(resp.status_code, 200) - data = resp.get_json() - for item in data['items']: - self.assertEqual(item['test'], test_name) - uuids = [item['uuid'] for item in data['items']] - self.assertIn(fc_uuid, uuids) - - def test_list_filter_by_metric(self): - """Filter unassigned field changes by metric name.""" - unique = uuid.uuid4().hex[:8] - machine_name = f'fc-filter-met-{unique}' - rev1 = f'fc-fmet-o1-{uuid.uuid4().hex[:8]}' - rev2 = f'fc-fmet-o2-{uuid.uuid4().hex[:8]}' - test_name = f'fc/filter-met/{uuid.uuid4().hex[:8]}' - submit_run(self.client, machine_name, rev1, - [{'name': test_name, 'execution_time': [1.0]}]) - submit_run(self.client, machine_name, rev2, - [{'name': test_name, 'execution_time': [2.0]}]) - fc = submit_fieldchange(self.client, self.app, machine_name, - test_name, 'execution_time', rev1, rev2) - fc_uuid = fc['uuid'] - - resp = self.client.get( - PREFIX + '/field-changes?metric=execution_time') - self.assertEqual(resp.status_code, 200) - data = resp.get_json() - for item in data['items']: - self.assertEqual(item['metric'], 'execution_time') - uuids = [item['uuid'] for item in data['items']] - self.assertIn(fc_uuid, uuids) - - def test_list_filter_nonexistent_machine_404(self): - """Filtering by a nonexistent machine name returns 404.""" - resp = self.client.get( - PREFIX + '/field-changes?machine=no-such-machine-xyz') - self.assertEqual(resp.status_code, 404) - - def test_list_filter_nonexistent_test_404(self): - """Filtering by a nonexistent test name returns 404.""" - resp = self.client.get( - PREFIX + '/field-changes?test=no/such/test/xyz') - self.assertEqual(resp.status_code, 404) - - def test_list_filter_unknown_metric_400(self): - """Filtering by an unknown metric name returns 400.""" - resp = self.client.get( - PREFIX + '/field-changes?metric=no_such_metric_xyz') - self.assertEqual(resp.status_code, 400) - - def test_list_pagination(self): - """Test pagination of unassigned field changes.""" - for _ in range(3): - _create_unassigned_fieldchange(self.client, self.app) - resp = self.client.get(PREFIX + '/field-changes?limit=2') - self.assertEqual(resp.status_code, 200) - data = resp.get_json() - self.assertLessEqual(len(data['items']), 2) - if data['cursor']['next']: - cursor = data['cursor']['next'] - resp2 = self.client.get( - PREFIX + f'/field-changes?limit=2&cursor={cursor}') - self.assertEqual(resp2.status_code, 200) - - def test_invalid_cursor_returns_400(self): - """An invalid cursor string should return 400.""" - resp = self.client.get( - PREFIX + '/field-changes?cursor=not-a-valid-cursor!!!') - self.assertEqual(resp.status_code, 400) - - -# ========================================================================== -# Pagination Tests -# ========================================================================== - -class TestFieldChangePagination(unittest.TestCase): - """Exhaustive cursor pagination tests for GET /api/v5/{ts}/field-changes.""" - @classmethod - def setUpClass(cls): - super().setUpClass() - cls.app = create_app(sys.argv[1]) - cls.client = create_client(cls.app) - cls._machine_name = f'pag-fc-m-{uuid.uuid4().hex[:8]}' - rev1 = f'pag-fc-o1-{uuid.uuid4().hex[:8]}' - rev2 = f'pag-fc-o2-{uuid.uuid4().hex[:8]}' - submit_run(cls.client, cls._machine_name, rev1, - [{'name': f'pag-fc/test/{i}', 'execution_time': [1.0]} - for i in range(5)]) - submit_run(cls.client, cls._machine_name, rev2, - [{'name': f'pag-fc/test/{i}', 'execution_time': [2.0]} - for i in range(5)]) - for i in range(5): - submit_fieldchange(cls.client, cls.app, cls._machine_name, - f'pag-fc/test/{i}', 'execution_time', - rev1, rev2, - old_value=float(i), new_value=float(i + 10)) - - def _collect_all_pages(self): - url = PREFIX + f'/field-changes?machine={self._machine_name}&limit=2' - return collect_all_pages(self, self.client, url) - - def test_pagination_collects_all_items(self): - """Paginating through all pages collects all 5 field changes.""" - all_items = self._collect_all_pages() - self.assertEqual(len(all_items), 5) - - def test_no_duplicate_items_across_pages(self): - """No duplicate field change UUIDs across pages.""" - all_items = self._collect_all_pages() - uuids = [item['uuid'] for item in all_items] - self.assertEqual(len(uuids), len(set(uuids))) - - -class TestFieldChangeUnknownParams(unittest.TestCase): - """Test that unknown query parameters are rejected with 400.""" - @classmethod - def setUpClass(cls): - super().setUpClass() - cls.app = create_app(sys.argv[1]) - cls.client = create_client(cls.app) - - def test_field_changes_list_unknown_param_returns_400(self): - resp = self.client.get(PREFIX + '/field-changes?bogus=1') - self.assertEqual(resp.status_code, 400) - data = resp.get_json() - self.assertIn('bogus', data['error']['message']) - - -# ========================================================================== -# Field Change Creation Tests -# ========================================================================== - -class TestFieldChangeCreate(unittest.TestCase): - """Tests for POST /api/v5/{ts}/field-changes.""" - - @classmethod - def setUpClass(cls): - super().setUpClass() - cls.app = create_app(sys.argv[1]) - cls.client = create_client(cls.app) - - cls._machine_name = f'create-fc-m-{uuid.uuid4().hex[:8]}' - cls._test_name = f'create-fc/test/{uuid.uuid4().hex[:8]}' - cls._start_commit = f'create-fc-c1-{uuid.uuid4().hex[:8]}' - cls._end_commit = f'create-fc-c2-{uuid.uuid4().hex[:8]}' - cls._field_name = 'execution_time' - - submit_run(cls.client, cls._machine_name, cls._start_commit, - [{'name': cls._test_name, 'execution_time': [1.0]}]) - submit_run(cls.client, cls._machine_name, cls._end_commit, - [{'name': cls._test_name, 'execution_time': [2.0]}]) - - def _valid_body(self, **overrides): - """Return a valid POST body dict with optional overrides.""" - body = { - 'machine': self._machine_name, - 'test': self._test_name, - 'metric': self._field_name, - 'old_value': 10.0, - 'new_value': 20.0, - 'start_commit': self._start_commit, - 'end_commit': self._end_commit, - } - body.update(overrides) - return body - - # -- Happy path -- - - def test_create_field_change_201(self): - """POST with valid body returns 201 and correct fields.""" - headers = _submit_headers(self.app) - headers['Content-Type'] = 'application/json' - body = self._valid_body() - resp = self.client.post( - PREFIX + '/field-changes', - data=json.dumps(body), - headers=headers, - ) - self.assertEqual(resp.status_code, 201) - data = resp.get_json() - self.assertIn('uuid', data) - self.assertEqual(data['machine'], self._machine_name) - self.assertEqual(data['test'], self._test_name) - self.assertEqual(data['metric'], self._field_name) - self.assertAlmostEqual(data['old_value'], 10.0) - self.assertAlmostEqual(data['new_value'], 20.0) - self.assertEqual(data['start_commit'], self._start_commit) - self.assertEqual(data['end_commit'], self._end_commit) - - def test_each_create_gets_unique_uuid(self): - """Two POSTs should produce field changes with different UUIDs.""" - headers = _submit_headers(self.app) - headers['Content-Type'] = 'application/json' - body = self._valid_body() - resp1 = self.client.post( - PREFIX + '/field-changes', - data=json.dumps(body), - headers=headers, - ) - resp2 = self.client.post( - PREFIX + '/field-changes', - data=json.dumps(body), - headers=headers, - ) - self.assertEqual(resp1.status_code, 201) - self.assertEqual(resp2.status_code, 201) - self.assertNotEqual( - resp1.get_json()['uuid'], resp2.get_json()['uuid']) - - def test_created_fc_appears_in_list(self): - """A created field change should appear in GET /field-changes.""" - headers = _submit_headers(self.app) - headers['Content-Type'] = 'application/json' - body = self._valid_body() - resp = self.client.post( - PREFIX + '/field-changes', - data=json.dumps(body), - headers=headers, - ) - self.assertEqual(resp.status_code, 201) - created_uuid = resp.get_json()['uuid'] - - # Fetch unassigned list - resp2 = self.client.get(PREFIX + '/field-changes') - self.assertEqual(resp2.status_code, 200) - uuids = [fc['uuid'] for fc in resp2.get_json()['items']] - self.assertIn(created_uuid, uuids) - - # -- Missing required fields -- - - def test_missing_machine_422(self): - headers = _submit_headers(self.app) - headers['Content-Type'] = 'application/json' - body = self._valid_body() - del body['machine'] - resp = self.client.post( - PREFIX + '/field-changes', - data=json.dumps(body), - headers=headers, - ) - self.assertEqual(resp.status_code, 422) - - def test_missing_test_422(self): - headers = _submit_headers(self.app) - headers['Content-Type'] = 'application/json' - body = self._valid_body() - del body['test'] - resp = self.client.post( - PREFIX + '/field-changes', - data=json.dumps(body), - headers=headers, - ) - self.assertEqual(resp.status_code, 422) - - def test_missing_metric_422(self): - headers = _submit_headers(self.app) - headers['Content-Type'] = 'application/json' - body = self._valid_body() - del body['metric'] - resp = self.client.post( - PREFIX + '/field-changes', - data=json.dumps(body), - headers=headers, - ) - self.assertEqual(resp.status_code, 422) - - def test_missing_old_value_422(self): - headers = _submit_headers(self.app) - headers['Content-Type'] = 'application/json' - body = self._valid_body() - del body['old_value'] - resp = self.client.post( - PREFIX + '/field-changes', - data=json.dumps(body), - headers=headers, - ) - self.assertEqual(resp.status_code, 422) - - def test_missing_new_value_422(self): - headers = _submit_headers(self.app) - headers['Content-Type'] = 'application/json' - body = self._valid_body() - del body['new_value'] - resp = self.client.post( - PREFIX + '/field-changes', - data=json.dumps(body), - headers=headers, - ) - self.assertEqual(resp.status_code, 422) - - def test_missing_start_commit_422(self): - headers = _submit_headers(self.app) - headers['Content-Type'] = 'application/json' - body = self._valid_body() - del body['start_commit'] - resp = self.client.post( - PREFIX + '/field-changes', - data=json.dumps(body), - headers=headers, - ) - self.assertEqual(resp.status_code, 422) - - def test_missing_end_commit_422(self): - headers = _submit_headers(self.app) - headers['Content-Type'] = 'application/json' - body = self._valid_body() - del body['end_commit'] - resp = self.client.post( - PREFIX + '/field-changes', - data=json.dumps(body), - headers=headers, - ) - self.assertEqual(resp.status_code, 422) - - # -- Nonexistent references -- - - def test_nonexistent_machine_404(self): - headers = _submit_headers(self.app) - headers['Content-Type'] = 'application/json' - body = self._valid_body(machine='no-such-machine-xyz') - resp = self.client.post( - PREFIX + '/field-changes', - data=json.dumps(body), - headers=headers, - ) - self.assertEqual(resp.status_code, 404) - - def test_nonexistent_test_404(self): - headers = _submit_headers(self.app) - headers['Content-Type'] = 'application/json' - body = self._valid_body(test='no/such/test/xyz') - resp = self.client.post( - PREFIX + '/field-changes', - data=json.dumps(body), - headers=headers, - ) - self.assertEqual(resp.status_code, 404) - - def test_unknown_metric_400(self): - headers = _submit_headers(self.app) - headers['Content-Type'] = 'application/json' - body = self._valid_body(metric='no_such_field_xyz') - resp = self.client.post( - PREFIX + '/field-changes', - data=json.dumps(body), - headers=headers, - ) - self.assertEqual(resp.status_code, 400) - - def test_nonexistent_start_commit_404(self): - headers = _submit_headers(self.app) - headers['Content-Type'] = 'application/json' - body = self._valid_body(start_commit='nonexistent-commit-xyz') - resp = self.client.post( - PREFIX + '/field-changes', - data=json.dumps(body), - headers=headers, - ) - self.assertEqual(resp.status_code, 404) - - def test_nonexistent_end_commit_404(self): - headers = _submit_headers(self.app) - headers['Content-Type'] = 'application/json' - body = self._valid_body(end_commit='nonexistent-commit-xyz') - resp = self.client.post( - PREFIX + '/field-changes', - data=json.dumps(body), - headers=headers, - ) - self.assertEqual(resp.status_code, 404) - - # -- Invalid body -- - - def test_empty_body_400(self): - headers = _submit_headers(self.app) - headers['Content-Type'] = 'application/json' - resp = self.client.post( - PREFIX + '/field-changes', - data='', - headers=headers, - ) - self.assertIn(resp.status_code, (400, 422)) - - def test_invalid_json_400(self): - headers = _submit_headers(self.app) - headers['Content-Type'] = 'application/json' - resp = self.client.post( - PREFIX + '/field-changes', - data='not json', - headers=headers, - ) - self.assertIn(resp.status_code, (400, 422)) - - # -- Auth -- - - def test_no_auth_401(self): - body = self._valid_body() - resp = self.client.post( - PREFIX + '/field-changes', - data=json.dumps(body), - content_type='application/json', - ) - self.assertEqual(resp.status_code, 401) - - def test_read_scope_403(self): - headers = make_scoped_headers(self.app, 'read') - headers['Content-Type'] = 'application/json' - body = self._valid_body() - resp = self.client.post( - PREFIX + '/field-changes', - data=json.dumps(body), - headers=headers, - ) - self.assertEqual(resp.status_code, 403) - - def test_admin_scope_201(self): - """Admin scope should also be allowed (higher than submit).""" - headers = admin_headers() - headers['Content-Type'] = 'application/json' - body = self._valid_body() - resp = self.client.post( - PREFIX + '/field-changes', - data=json.dumps(body), - headers=headers, - ) - self.assertEqual(resp.status_code, 201) - - -if __name__ == '__main__': - unittest.main(argv=[sys.argv[0]], exit=True) diff --git a/tests/server/api/v5/test_integration.py b/tests/server/api/v5/test_integration.py index a46c1fc20..86281c163 100644 --- a/tests/server/api/v5/test_integration.py +++ b/tests/server/api/v5/test_integration.py @@ -413,7 +413,7 @@ def test_discovery_nts_suite_has_all_expected_links(self): expected_keys = { 'machines', 'commits', 'runs', 'tests', - 'regressions', 'field_changes', 'query', + 'regressions', 'query', } self.assertEqual(set(links.keys()), expected_keys, "Discovery links mismatch") diff --git a/tests/server/api/v5/test_machines.py b/tests/server/api/v5/test_machines.py index 947118a97..27e313795 100644 --- a/tests/server/api/v5/test_machines.py +++ b/tests/server/api/v5/test_machines.py @@ -16,7 +16,7 @@ from v5_test_helpers import ( create_app, create_client, admin_headers, make_scoped_headers, create_machine, create_commit, create_run, - create_test, create_fieldchange, create_regression, + create_test, create_regression, collect_all_pages, submit_run, ) @@ -338,13 +338,13 @@ def test_delete_machine_with_runs(self): resp = self.client.get(PREFIX + f'/machines/{name}') self.assertEqual(resp.status_code, 404) - def test_delete_machine_with_fieldchanges(self): - """Delete machine whose FieldChanges are linked to RegressionIndicators. + def test_delete_machine_with_regression_indicators(self): + """Delete machine whose RegressionIndicators reference it. - Verifies the delete handler cleans up FieldChanges (which have no - CASCADE from machine_id) before deleting the machine. - RegressionIndicator.field_change_id has ondelete=CASCADE, so - those are auto-cleaned when the FieldChange is deleted. + Verifies the delete handler cleans up RegressionIndicators (which + have no CASCADE from machine_id) before deleting the machine. + The Regression itself remains (it may have other indicators on + different machines). """ name = f'delete-ri-{uuid.uuid4().hex[:8]}' db = self.app.instance.get_database("default") @@ -352,16 +352,12 @@ def test_delete_machine_with_fieldchanges(self): ts = db.testsuite[TS] machine = create_machine(session, ts, name=name) - c1 = create_commit( - session, ts, commit=f'ri-c1-{uuid.uuid4().hex[:8]}') - c2 = create_commit( - session, ts, commit=f'ri-c2-{uuid.uuid4().hex[:8]}') test = create_test( session, ts, name=f'ri/test/{uuid.uuid4().hex[:8]}') - fc = create_fieldchange(session, ts, c1, c2, machine, test, - 'execution_time') create_regression( - session, ts, title=f'Reg for {name}', field_changes=[fc]) + session, ts, title=f'Reg for {name}', + indicators=[{'machine_id': machine.id, 'test_id': test.id, + 'metric': 'execution_time'}]) session.commit() session.close() diff --git a/tests/server/api/v5/test_regressions.py b/tests/server/api/v5/test_regressions.py index 6894535de..7d8335db9 100644 --- a/tests/server/api/v5/test_regressions.py +++ b/tests/server/api/v5/test_regressions.py @@ -14,7 +14,8 @@ sys.path.insert(0, os.path.dirname(__file__)) from v5_test_helpers import ( create_app, create_client, make_scoped_headers, - collect_all_pages, submit_run, submit_fieldchange, submit_regression, + collect_all_pages, submit_run, submit_regression, + create_machine, create_commit, create_test, ) @@ -26,54 +27,43 @@ def _triage_headers(app): return make_scoped_headers(app, 'triage') -def _setup_fieldchange(client, app): - """Create a field change via the API and return its UUID.""" - tag = uuid.uuid4().hex[:8] - machine = f'reg-m-{tag}' - rev1 = f'reg-o1-{tag}' - rev2 = f'reg-o2-{tag}' - test = f'reg/test/{tag}' - submit_run(client, machine, rev1, - [{'name': test, 'execution_time': [1.0]}]) - submit_run(client, machine, rev2, - [{'name': test, 'execution_time': [2.0]}]) - fc = submit_fieldchange(client, app, machine, test, - 'execution_time', rev1, rev2) - return fc['uuid'] - - -def _setup_regression_with_indicators(client, app, num_indicators=2): - """Create a regression with field changes via the API. - - Returns (regression_uuid, [fc_uuid, ...]). +def _setup_regression_with_indicators(client, app, num_indicators=2, + state='active', commit=None): + """Create a regression with indicators via the API. + + Returns (regression_uuid, [indicator_uuid, ...]). """ tag = uuid.uuid4().hex[:8] machine = f'reg-m-{tag}' - rev1 = f'reg-o1-{tag}' - rev2 = f'reg-o2-{tag}' - tests = [ - {'name': f'reg/test/{tag}/{i}', 'execution_time': [1.0 + i]} - for i in range(num_indicators) + tests = [f'reg/test/{tag}/{i}' for i in range(num_indicators)] + + # Ensure machine and tests exist by submitting a run + submit_run(client, machine, f'reg-rev-{tag}', + [{'name': t, 'execution_time': [1.0 + i]} + for i, t in enumerate(tests)]) + + indicators = [ + {'machine': machine, 'test': t, 'metric': 'execution_time'} + for t in tests ] - submit_run(client, machine, rev1, tests) - submit_run(client, machine, rev2, [ - {'name': f'reg/test/{tag}/{i}', 'execution_time': [2.0 + i]} - for i in range(num_indicators) - ]) - fc_uuids = [] - for i in range(num_indicators): - fc = submit_fieldchange(client, app, machine, - f'reg/test/{tag}/{i}', - 'execution_time', rev1, rev2) - fc_uuids.append(fc['uuid']) - reg = submit_regression(client, app, fc_uuids) - return reg['uuid'], fc_uuids + reg = submit_regression(client, app, indicators=indicators, + state=state, commit=commit) + indicator_uuids = [ind['uuid'] for ind in reg['indicators']] + return reg['uuid'], indicator_uuids # ========================================================================== # Regression List Tests # ========================================================================== +def _find_in_list(items, uuid): + """Find an item by UUID in a list response's items array.""" + for r in items: + if r['uuid'] == uuid: + return r + return None + + class TestRegressionList(unittest.TestCase): @classmethod def setUpClass(cls): @@ -93,23 +83,34 @@ def test_list_returns_200_with_envelope(self): def test_list_item_has_expected_fields(self): reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) - resp = self.client.get(PREFIX + '/regressions') + resp = self.client.get(PREFIX + '/regressions?limit=500') data = resp.get_json() - item = None - for r in data['items']: - if r['uuid'] == reg_uuid: - item = r - break + item = _find_in_list(data['items'], reg_uuid) self.assertIsNotNone(item) self.assertIn('uuid', item) self.assertIn('title', item) self.assertIn('bug', item) self.assertIn('state', item) + self.assertIn('commit', item) + self.assertIn('machine_count', item) + self.assertIn('test_count', item) # List items should NOT have indicators embedded self.assertNotIn('indicators', item) + def test_list_item_machine_and_test_counts(self): + """Create a regression with 2 indicators (1 machine, 2 tests). + Verify machine_count == 1 and test_count == 2.""" + reg_uuid, _ = _setup_regression_with_indicators( + self.client, self.app, 2) + resp = self.client.get(PREFIX + '/regressions?limit=500') + data = resp.get_json() + item = _find_in_list(data['items'], reg_uuid) + self.assertIsNotNone(item) + self.assertEqual(item['machine_count'], 1) + self.assertEqual(item['test_count'], 2) + def test_list_filter_by_state(self): - reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) + _setup_regression_with_indicators(self.client, self.app, 1) resp = self.client.get(PREFIX + '/regressions?state=active') self.assertEqual(resp.status_code, 200) data = resp.get_json() @@ -119,28 +120,24 @@ def test_list_filter_by_state(self): def test_list_filter_by_state_multiple(self): tag = uuid.uuid4().hex[:8] machine = f'state-m-{tag}' - rev1 = f'state-o1-{tag}' - rev2 = f'state-o2-{tag}' test1 = f'state-test/{tag}/1' test2 = f'state-test/{tag}/2' - submit_run(self.client, machine, rev1, [ + submit_run(self.client, machine, f'state-rev-{tag}', [ {'name': test1, 'execution_time': [1.0]}, {'name': test2, 'execution_time': [1.0]}, ]) - submit_run(self.client, machine, rev2, [ - {'name': test1, 'execution_time': [2.0]}, - {'name': test2, 'execution_time': [2.0]}, - ]) - fc1 = submit_fieldchange(self.client, self.app, machine, - test1, 'execution_time', rev1, rev2) - fc2 = submit_fieldchange(self.client, self.app, machine, - test2, 'execution_time', rev1, rev2) - submit_regression(self.client, self.app, [fc1['uuid']], - state='active') - submit_regression(self.client, self.app, [fc2['uuid']], - state='detected') + submit_regression( + self.client, self.app, + indicators=[{'machine': machine, 'test': test1, + 'metric': 'execution_time'}], + state='active') + submit_regression( + self.client, self.app, + indicators=[{'machine': machine, 'test': test2, + 'metric': 'execution_time'}], + state='detected') resp = self.client.get( PREFIX + '/regressions?state=active,detected') @@ -179,7 +176,7 @@ def test_list_pagination(self): # ========================================================================== class TestRegressionListFilters(unittest.TestCase): - """Tests for machine, test, and metric query filters on the list endpoint.""" + """Tests for machine, test, metric, commit, and has_commit filters.""" @classmethod def setUpClass(cls): @@ -197,18 +194,15 @@ def test_list_filter_by_machine(self): """Filter by machine name returns only regressions on that machine.""" tag = uuid.uuid4().hex[:8] machine_name = f'filter-m-{tag}' - rev1 = f'filter-r1-{tag}' - rev2 = f'filter-r2-{tag}' test_name = f'filter/test/{tag}' - submit_run(self.client, machine_name, rev1, + submit_run(self.client, machine_name, f'filter-r1-{tag}', [{'name': test_name, 'execution_time': [1.0]}]) - submit_run(self.client, machine_name, rev2, - [{'name': test_name, 'execution_time': [2.0]}]) - fc = submit_fieldchange(self.client, self.app, machine_name, - test_name, 'execution_time', rev1, rev2) - reg = submit_regression(self.client, self.app, [fc['uuid']]) + reg = submit_regression( + self.client, self.app, + indicators=[{'machine': machine_name, 'test': test_name, + 'metric': 'execution_time'}]) uuids = self._collect_filtered(f'machine={machine_name}') self.assertIn(reg['uuid'], uuids) @@ -217,18 +211,15 @@ def test_list_filter_by_test(self): """Filter by test name returns only regressions on that test.""" tag = uuid.uuid4().hex[:8] machine_name = f'filter-tm-{tag}' - rev1 = f'filter-tr1-{tag}' - rev2 = f'filter-tr2-{tag}' test_name = f'filter/testname/{tag}' - submit_run(self.client, machine_name, rev1, + submit_run(self.client, machine_name, f'filter-tr1-{tag}', [{'name': test_name, 'execution_time': [1.0]}]) - submit_run(self.client, machine_name, rev2, - [{'name': test_name, 'execution_time': [2.0]}]) - fc = submit_fieldchange(self.client, self.app, machine_name, - test_name, 'execution_time', rev1, rev2) - reg = submit_regression(self.client, self.app, [fc['uuid']]) + reg = submit_regression( + self.client, self.app, + indicators=[{'machine': machine_name, 'test': test_name, + 'metric': 'execution_time'}]) uuids = self._collect_filtered(f'test={test_name}') self.assertIn(reg['uuid'], uuids) @@ -237,30 +228,26 @@ def test_list_filter_by_metric(self): """Filter by metric returns only regressions with that metric.""" tag = uuid.uuid4().hex[:8] machine_name = f'filter-mm-{tag}' - rev1 = f'filter-mr1-{tag}' - rev2 = f'filter-mr2-{tag}' test_ct = f'filter/compile/{tag}' test_et = f'filter/exec/{tag}' # Submit runs with both metrics - submit_run(self.client, machine_name, rev1, [ + submit_run(self.client, machine_name, f'filter-mr1-{tag}', [ {'name': test_ct, 'compile_time': [5.0]}, {'name': test_et, 'execution_time': [1.0]}, ]) - submit_run(self.client, machine_name, rev2, [ - {'name': test_ct, 'compile_time': [10.0]}, - {'name': test_et, 'execution_time': [2.0]}, - ]) - # Create field change + regression for compile_time - fc_ct = submit_fieldchange(self.client, self.app, machine_name, - test_ct, 'compile_time', rev1, rev2) - reg_ct = submit_regression(self.client, self.app, [fc_ct['uuid']]) + # Create regression for compile_time + reg_ct = submit_regression( + self.client, self.app, + indicators=[{'machine': machine_name, 'test': test_ct, + 'metric': 'compile_time'}]) - # Create field change + regression for execution_time - fc_et = submit_fieldchange(self.client, self.app, machine_name, - test_et, 'execution_time', rev1, rev2) - reg_et = submit_regression(self.client, self.app, [fc_et['uuid']]) + # Create regression for execution_time + reg_et = submit_regression( + self.client, self.app, + indicators=[{'machine': machine_name, 'test': test_et, + 'metric': 'execution_time'}]) # Filter by execution_time -- should include reg_et, exclude reg_ct uuids = self._collect_filtered('metric=execution_time') @@ -289,24 +276,105 @@ def test_list_filter_combined(self): """Combined machine + test + metric filter narrows results.""" tag = uuid.uuid4().hex[:8] machine_name = f'filter-cm-{tag}' - rev1 = f'filter-cr1-{tag}' - rev2 = f'filter-cr2-{tag}' test_name = f'filter/combined/{tag}' - submit_run(self.client, machine_name, rev1, + submit_run(self.client, machine_name, f'filter-cr1-{tag}', [{'name': test_name, 'execution_time': [1.0]}]) - submit_run(self.client, machine_name, rev2, - [{'name': test_name, 'execution_time': [2.0]}]) - fc = submit_fieldchange(self.client, self.app, machine_name, - test_name, 'execution_time', rev1, rev2) - reg = submit_regression(self.client, self.app, [fc['uuid']]) + reg = submit_regression( + self.client, self.app, + indicators=[{'machine': machine_name, 'test': test_name, + 'metric': 'execution_time'}]) uuids = self._collect_filtered( f'machine={machine_name}&test={test_name}' f'&metric=execution_time') self.assertIn(reg['uuid'], uuids) + def test_list_filter_by_commit(self): + """Filter by commit returns only regressions with that commit.""" + tag = uuid.uuid4().hex[:8] + machine = f'fc-m-{tag}' + test = f'fc/test/{tag}' + rev1 = f'fc-rev1-{tag}' + rev2 = f'fc-rev2-{tag}' + + submit_run(self.client, machine, rev1, + [{'name': test, 'execution_time': [1.0]}]) + submit_run(self.client, machine, rev2, + [{'name': test, 'execution_time': [2.0]}]) + + reg1 = submit_regression( + self.client, self.app, + indicators=[{'machine': machine, 'test': test, + 'metric': 'execution_time'}], + commit=rev1) + reg2 = submit_regression( + self.client, self.app, + indicators=[{'machine': machine, 'test': test, + 'metric': 'execution_time'}], + commit=rev2) + + uuids = self._collect_filtered(f'commit={rev1}') + self.assertIn(reg1['uuid'], uuids) + self.assertNotIn(reg2['uuid'], uuids) + + def test_list_filter_by_has_commit(self): + """has_commit=true/false filters correctly.""" + tag = uuid.uuid4().hex[:8] + machine = f'hc-m-{tag}' + test1 = f'hc/test1/{tag}' + test2 = f'hc/test2/{tag}' + rev = f'hc-rev-{tag}' + + submit_run(self.client, machine, rev, [ + {'name': test1, 'execution_time': [1.0]}, + {'name': test2, 'execution_time': [1.0]}, + ]) + + reg_with = submit_regression( + self.client, self.app, + indicators=[{'machine': machine, 'test': test1, + 'metric': 'execution_time'}], + commit=rev) + reg_without = submit_regression( + self.client, self.app, + indicators=[{'machine': machine, 'test': test2, + 'metric': 'execution_time'}]) + + for filter_val, in_with, in_without in [ + ('true', True, False), + ('false', False, True), + ]: + with self.subTest(has_commit=filter_val): + uuids = self._collect_filtered(f'has_commit={filter_val}') + check = self.assertIn if in_with else self.assertNotIn + check(reg_with['uuid'], uuids) + check = self.assertIn if in_without else self.assertNotIn + check(reg_without['uuid'], uuids) + + def test_list_item_commit_value(self): + """List item contains the commit string value.""" + tag = uuid.uuid4().hex[:8] + machine = f'lcv-m-{tag}' + test = f'lcv/test/{tag}' + rev = f'lcv-rev-{tag}' + + submit_run(self.client, machine, rev, + [{'name': test, 'execution_time': [1.0]}]) + + reg = submit_regression( + self.client, self.app, + indicators=[{'machine': machine, 'test': test, + 'metric': 'execution_time'}], + commit=rev) + + resp = self.client.get(PREFIX + '/regressions?limit=500') + data = resp.get_json() + item = _find_in_list(data['items'], reg['uuid']) + self.assertIsNotNone(item) + self.assertEqual(item['commit'], rev) + # ========================================================================== # Regression Create Tests @@ -319,12 +387,23 @@ def setUpClass(cls): cls.app = create_app(sys.argv[1]) cls.client = create_client(cls.app) + def _setup_machine_and_test(self): + """Create machine and test via a run, return (machine_name, test_name).""" + tag = uuid.uuid4().hex[:8] + machine = f'cr-m-{tag}' + test = f'cr/test/{tag}' + submit_run(self.client, machine, f'cr-rev-{tag}', + [{'name': test, 'execution_time': [1.0]}]) + return machine, test + def test_create_regression(self): - fc_uuid = _setup_fieldchange(self.client, self.app) + machine, test = self._setup_machine_and_test() headers = _triage_headers(self.app) resp = self.client.post( PREFIX + '/regressions', - json={'field_change_uuids': [fc_uuid]}, + json={'indicators': [ + {'machine': machine, 'test': test, 'metric': 'execution_time'} + ]}, headers=headers, ) self.assertEqual(resp.status_code, 201) @@ -332,15 +411,22 @@ def test_create_regression(self): self.assertIn('uuid', data) self.assertIn('indicators', data) self.assertEqual(len(data['indicators']), 1) - self.assertEqual(data['indicators'][0]['field_change_uuid'], fc_uuid) + ind = data['indicators'][0] + self.assertIn('uuid', ind) + self.assertEqual(ind['machine'], machine) + self.assertEqual(ind['test'], test) + self.assertEqual(ind['metric'], 'execution_time') def test_create_with_custom_title(self): - fc_uuid = _setup_fieldchange(self.client, self.app) + machine, test = self._setup_machine_and_test() headers = _triage_headers(self.app) resp = self.client.post( PREFIX + '/regressions', json={ - 'field_change_uuids': [fc_uuid], + 'indicators': [ + {'machine': machine, 'test': test, + 'metric': 'execution_time'} + ], 'title': 'Custom Title', }, headers=headers, @@ -350,12 +436,15 @@ def test_create_with_custom_title(self): self.assertEqual(data['title'], 'Custom Title') def test_create_with_state(self): - fc_uuid = _setup_fieldchange(self.client, self.app) + machine, test = self._setup_machine_and_test() headers = _triage_headers(self.app) resp = self.client.post( PREFIX + '/regressions', json={ - 'field_change_uuids': [fc_uuid], + 'indicators': [ + {'machine': machine, 'test': test, + 'metric': 'execution_time'} + ], 'state': 'active', }, headers=headers, @@ -365,53 +454,137 @@ def test_create_with_state(self): self.assertEqual(data['state'], 'active') def test_create_default_state_detected(self): - fc_uuid = _setup_fieldchange(self.client, self.app) + machine, test = self._setup_machine_and_test() headers = _triage_headers(self.app) resp = self.client.post( PREFIX + '/regressions', - json={'field_change_uuids': [fc_uuid]}, + json={'indicators': [ + {'machine': machine, 'test': test, 'metric': 'execution_time'} + ]}, headers=headers, ) self.assertEqual(resp.status_code, 201) data = resp.get_json() self.assertEqual(data['state'], 'detected') - def test_create_missing_field_changes_422(self): + def test_create_empty_body_succeeds(self): + """Empty body (no indicators) should succeed.""" headers = _triage_headers(self.app) resp = self.client.post( PREFIX + '/regressions', json={}, headers=headers, ) - self.assertEqual(resp.status_code, 422) + self.assertEqual(resp.status_code, 201) + data = resp.get_json() + self.assertIn('uuid', data) + self.assertEqual(len(data['indicators']), 0) + + def test_create_with_commit(self): + """Create a regression with a commit field.""" + tag = uuid.uuid4().hex[:8] + machine = f'cc-m-{tag}' + test = f'cc/test/{tag}' + rev = f'cc-rev-{tag}' + submit_run(self.client, machine, rev, + [{'name': test, 'execution_time': [1.0]}]) - def test_create_empty_field_changes_422(self): headers = _triage_headers(self.app) resp = self.client.post( PREFIX + '/regressions', - json={'field_change_uuids': []}, + json={ + 'indicators': [ + {'machine': machine, 'test': test, + 'metric': 'execution_time'} + ], + 'commit': rev, + }, headers=headers, ) - self.assertEqual(resp.status_code, 422) + self.assertEqual(resp.status_code, 201) + data = resp.get_json() + self.assertEqual(data['commit'], rev) + + def test_create_with_notes(self): + """Create a regression with notes field.""" + headers = _triage_headers(self.app) + resp = self.client.post( + PREFIX + '/regressions', + json={'notes': 'Investigation notes here'}, + headers=headers, + ) + self.assertEqual(resp.status_code, 201) + data = resp.get_json() + self.assertEqual(data['notes'], 'Investigation notes here') + + def test_create_nonexistent_machine_404(self): + """Indicator referencing a nonexistent machine returns 404.""" + tag = uuid.uuid4().hex[:8] + # Create a test but not a machine + machine_ok = f'cnm-m-{tag}' + test_name = f'cnm/test/{tag}' + submit_run(self.client, machine_ok, f'cnm-rev-{tag}', + [{'name': test_name, 'execution_time': [1.0]}]) + + headers = _triage_headers(self.app) + resp = self.client.post( + PREFIX + '/regressions', + json={'indicators': [ + {'machine': 'nonexistent-machine-xyz', + 'test': test_name, 'metric': 'execution_time'} + ]}, + headers=headers, + ) + self.assertEqual(resp.status_code, 404) + + def test_create_nonexistent_test_404(self): + """Indicator referencing a nonexistent test returns 404.""" + tag = uuid.uuid4().hex[:8] + machine = f'cnt-m-{tag}' + submit_run(self.client, machine, f'cnt-rev-{tag}', + [{'name': f'cnt/test/{tag}', 'execution_time': [1.0]}]) + + headers = _triage_headers(self.app) + resp = self.client.post( + PREFIX + '/regressions', + json={'indicators': [ + {'machine': machine, + 'test': 'nonexistent/test/xyz', + 'metric': 'execution_time'} + ]}, + headers=headers, + ) + self.assertEqual(resp.status_code, 404) - def test_create_invalid_field_change_uuid_404(self): + def test_create_unknown_metric_400(self): + """Indicator referencing an unknown metric returns 400.""" + machine, test = self._setup_machine_and_test() headers = _triage_headers(self.app) resp = self.client.post( PREFIX + '/regressions', - json={'field_change_uuids': ['nonexistent-uuid']}, + json={'indicators': [ + {'machine': machine, 'test': test, + 'metric': 'nonexistent_metric'} + ]}, + headers=headers, + ) + self.assertEqual(resp.status_code, 400) + + def test_create_nonexistent_commit_404(self): + """Commit field referencing a nonexistent commit returns 404.""" + headers = _triage_headers(self.app) + resp = self.client.post( + PREFIX + '/regressions', + json={'commit': 'nonexistent-commit-xyz'}, headers=headers, ) self.assertEqual(resp.status_code, 404) def test_create_invalid_state_422(self): - fc_uuid = _setup_fieldchange(self.client, self.app) headers = _triage_headers(self.app) resp = self.client.post( PREFIX + '/regressions', - json={ - 'field_change_uuids': [fc_uuid], - 'state': 'bogus_state', - }, + json={'state': 'bogus_state'}, headers=headers, ) self.assertEqual(resp.status_code, 422) @@ -419,7 +592,7 @@ def test_create_invalid_state_422(self): def test_create_no_auth_401(self): resp = self.client.post( PREFIX + '/regressions', - json={'field_change_uuids': ['x']}, + json={}, ) self.assertEqual(resp.status_code, 401) @@ -427,7 +600,7 @@ def test_create_read_scope_403(self): headers = make_scoped_headers(self.app, 'read') resp = self.client.post( PREFIX + '/regressions', - json={'field_change_uuids': ['x']}, + json={}, headers=headers, ) self.assertEqual(resp.status_code, 403) @@ -445,25 +618,30 @@ def setUpClass(cls): cls.client = create_client(cls.app) def test_get_detail(self): - reg_uuid, fc_uuids = _setup_regression_with_indicators(self.client, self.app, 1) + reg_uuid, _ = _setup_regression_with_indicators( + self.client, self.app, 1) resp = self.client.get(PREFIX + f'/regressions/{reg_uuid}') self.assertEqual(resp.status_code, 200) data = resp.get_json() self.assertEqual(data['uuid'], reg_uuid) self.assertIn('title', data) self.assertIn('bug', data) + self.assertIn('notes', data) self.assertIn('state', data) + self.assertIn('commit', data) self.assertIn('indicators', data) self.assertEqual(len(data['indicators']), 1) ind = data['indicators'][0] - self.assertIn('field_change_uuid', ind) + self.assertIn('uuid', ind) self.assertIn('test', ind) self.assertIn('machine', ind) self.assertIn('metric', ind) - self.assertIn('old_value', ind) - self.assertIn('new_value', ind) - self.assertIn('start_commit', ind) - self.assertIn('end_commit', ind) + # Old fields should NOT be present + self.assertNotIn('field_change_uuid', ind) + self.assertNotIn('old_value', ind) + self.assertNotIn('new_value', ind) + self.assertNotIn('start_commit', ind) + self.assertNotIn('end_commit', ind) def test_detail_nonexistent_404(self): resp = self.client.get( @@ -471,7 +649,8 @@ def test_detail_nonexistent_404(self): self.assertEqual(resp.status_code, 404) def test_detail_state_is_string(self): - reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) + reg_uuid, _ = _setup_regression_with_indicators( + self.client, self.app, 1) resp = self.client.get(PREFIX + f'/regressions/{reg_uuid}') data = resp.get_json() self.assertIsInstance(data['state'], str) @@ -488,7 +667,8 @@ def setUpClass(cls): def test_etag_present_on_detail(self): """Regression detail response should include an ETag header.""" - reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) + reg_uuid, _ = _setup_regression_with_indicators( + self.client, self.app, 1) resp = self.client.get(PREFIX + f'/regressions/{reg_uuid}') self.assertEqual(resp.status_code, 200) etag = resp.headers.get('ETag') @@ -497,7 +677,8 @@ def test_etag_present_on_detail(self): def test_etag_304_on_match(self): """Sending If-None-Match with the same ETag returns 304.""" - reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) + reg_uuid, _ = _setup_regression_with_indicators( + self.client, self.app, 1) resp = self.client.get(PREFIX + f'/regressions/{reg_uuid}') etag = resp.headers.get('ETag') @@ -509,7 +690,8 @@ def test_etag_304_on_match(self): def test_etag_200_on_mismatch(self): """Sending If-None-Match with a different ETag returns 200.""" - reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) + reg_uuid, _ = _setup_regression_with_indicators( + self.client, self.app, 1) resp = self.client.get( PREFIX + f'/regressions/{reg_uuid}', headers={'If-None-Match': 'W/"stale-etag-value"'}, @@ -530,7 +712,8 @@ def setUpClass(cls): cls.client = create_client(cls.app) def test_update_title(self): - reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) + reg_uuid, _ = _setup_regression_with_indicators( + self.client, self.app, 1) headers = _triage_headers(self.app) resp = self.client.patch( PREFIX + f'/regressions/{reg_uuid}', @@ -542,7 +725,8 @@ def test_update_title(self): self.assertEqual(data['title'], 'Updated Title') def test_update_bug(self): - reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) + reg_uuid, _ = _setup_regression_with_indicators( + self.client, self.app, 1) headers = _triage_headers(self.app) resp = self.client.patch( PREFIX + f'/regressions/{reg_uuid}', @@ -554,7 +738,8 @@ def test_update_bug(self): self.assertEqual(data['bug'], 'https://bugs.example.com/123') def test_update_state(self): - reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) + reg_uuid, _ = _setup_regression_with_indicators( + self.client, self.app, 1) headers = _triage_headers(self.app) resp = self.client.patch( PREFIX + f'/regressions/{reg_uuid}', @@ -565,19 +750,95 @@ def test_update_state(self): data = resp.get_json() self.assertEqual(data['state'], 'fixed') + def test_update_notes(self): + reg_uuid, _ = _setup_regression_with_indicators( + self.client, self.app, 1) + headers = _triage_headers(self.app) + resp = self.client.patch( + PREFIX + f'/regressions/{reg_uuid}', + json={'notes': 'Updated investigation notes'}, + headers=headers, + ) + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertEqual(data['notes'], 'Updated investigation notes') + + def test_update_commit(self): + tag = uuid.uuid4().hex[:8] + machine = f'uc-m-{tag}' + test = f'uc/test/{tag}' + rev = f'uc-rev-{tag}' + submit_run(self.client, machine, rev, + [{'name': test, 'execution_time': [1.0]}]) + + reg_uuid, _ = _setup_regression_with_indicators( + self.client, self.app, 1) + headers = _triage_headers(self.app) + resp = self.client.patch( + PREFIX + f'/regressions/{reg_uuid}', + json={'commit': rev}, + headers=headers, + ) + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertEqual(data['commit'], rev) + + def test_clear_commit(self): + """PATCH commit=null clears the commit.""" + tag = uuid.uuid4().hex[:8] + machine = f'clc-m-{tag}' + test = f'clc/test/{tag}' + rev = f'clc-rev-{tag}' + submit_run(self.client, machine, rev, + [{'name': test, 'execution_time': [1.0]}]) + + reg_uuid, _ = _setup_regression_with_indicators( + self.client, self.app, 1, commit=rev) + headers = _triage_headers(self.app) + resp = self.client.patch( + PREFIX + f'/regressions/{reg_uuid}', + json={'commit': None}, + headers=headers, + ) + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertIsNone(data['commit']) + + def test_clear_notes(self): + """PATCH notes=null clears the notes.""" + reg_uuid, _ = _setup_regression_with_indicators( + self.client, self.app, 1) + headers = _triage_headers(self.app) + # Set notes first + self.client.patch( + PREFIX + f'/regressions/{reg_uuid}', + json={'notes': 'Some notes'}, + headers=headers, + ) + # Clear notes + resp = self.client.patch( + PREFIX + f'/regressions/{reg_uuid}', + json={'notes': None}, + headers=headers, + ) + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertIsNone(data['notes']) + def test_update_state_any_transition(self): """State transitions are unconstrained -- any -> any.""" - reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) + reg_uuid, _ = _setup_regression_with_indicators( + self.client, self.app, 1) headers = _triage_headers(self.app) - # active -> ignored + # active -> false_positive resp = self.client.patch( PREFIX + f'/regressions/{reg_uuid}', - json={'state': 'ignored'}, + json={'state': 'false_positive'}, headers=headers, ) self.assertEqual(resp.status_code, 200) - self.assertEqual(resp.get_json()['state'], 'ignored') - # ignored -> detected + self.assertEqual(resp.get_json()['state'], 'false_positive') + # false_positive -> detected resp = self.client.patch( PREFIX + f'/regressions/{reg_uuid}', json={'state': 'detected'}, @@ -587,7 +848,8 @@ def test_update_state_any_transition(self): self.assertEqual(resp.get_json()['state'], 'detected') def test_update_invalid_state_422(self): - reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) + reg_uuid, _ = _setup_regression_with_indicators( + self.client, self.app, 1) headers = _triage_headers(self.app) resp = self.client.patch( PREFIX + f'/regressions/{reg_uuid}', @@ -606,7 +868,8 @@ def test_update_nonexistent_404(self): self.assertEqual(resp.status_code, 404) def test_update_no_auth_401(self): - reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) + reg_uuid, _ = _setup_regression_with_indicators( + self.client, self.app, 1) resp = self.client.patch( PREFIX + f'/regressions/{reg_uuid}', json={'title': 'x'}, @@ -614,7 +877,8 @@ def test_update_no_auth_401(self): self.assertEqual(resp.status_code, 401) def test_update_read_scope_403(self): - reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) + reg_uuid, _ = _setup_regression_with_indicators( + self.client, self.app, 1) headers = make_scoped_headers(self.app, 'read') resp = self.client.patch( PREFIX + f'/regressions/{reg_uuid}', @@ -625,7 +889,8 @@ def test_update_read_scope_403(self): def test_update_returns_indicators(self): """PATCH response should include indicators.""" - reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 2) + reg_uuid, _ = _setup_regression_with_indicators( + self.client, self.app, 2) headers = _triage_headers(self.app) resp = self.client.patch( PREFIX + f'/regressions/{reg_uuid}', @@ -650,7 +915,8 @@ def setUpClass(cls): cls.client = create_client(cls.app) def test_delete_regression(self): - reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) + reg_uuid, _ = _setup_regression_with_indicators( + self.client, self.app, 1) headers = _triage_headers(self.app) resp = self.client.delete( PREFIX + f'/regressions/{reg_uuid}', @@ -671,7 +937,8 @@ def test_delete_nonexistent_404(self): self.assertEqual(resp.status_code, 404) def test_delete_no_auth_401(self): - reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) + reg_uuid, _ = _setup_regression_with_indicators( + self.client, self.app, 1) resp = self.client.delete( PREFIX + f'/regressions/{reg_uuid}', ) @@ -679,334 +946,201 @@ def test_delete_no_auth_401(self): # ========================================================================== -# Regression Merge Tests +# Regression Indicators Tests # ========================================================================== -class TestRegressionMerge(unittest.TestCase): +class TestRegressionIndicators(unittest.TestCase): @classmethod def setUpClass(cls): super().setUpClass() cls.app = create_app(sys.argv[1]) cls.client = create_client(cls.app) - def test_merge_regressions(self): - """Merge source into target: target gets all indicators.""" - target_uuid, target_fcs = _setup_regression_with_indicators( - self.client, self.app, 2) - source_uuid, source_fcs = _setup_regression_with_indicators( - self.client, self.app, 2) - headers = _triage_headers(self.app) - - resp = self.client.post( - PREFIX + f'/regressions/{target_uuid}/merge', - json={'source_regression_uuids': [source_uuid]}, - headers=headers, - ) - self.assertEqual(resp.status_code, 200) - data = resp.get_json() - # Target should now have all 4 indicators - self.assertEqual(len(data['indicators']), 4) - - # Source should be marked as IGNORED - resp2 = self.client.get(PREFIX + f'/regressions/{source_uuid}') - self.assertEqual(resp2.status_code, 200) - self.assertEqual(resp2.get_json()['state'], 'ignored') + def test_add_indicator(self): + """Add an indicator to an existing regression.""" + reg_uuid, _ = _setup_regression_with_indicators( + self.client, self.app, 1) - def test_merge_deduplicates_indicators(self): - """If source has same field change as target, deduplicate.""" + # Create a new test/machine for the new indicator tag = uuid.uuid4().hex[:8] - machine = f'dup-m-{tag}' - rev1 = f'dup-o1-{tag}' - rev2 = f'dup-o2-{tag}' - test1 = f'dup-test/{tag}' - test2 = f'dup-test2/{tag}' - - submit_run(self.client, machine, rev1, [ - {'name': test1, 'execution_time': [1.0]}, - {'name': test2, 'execution_time': [1.0]}, - ]) - submit_run(self.client, machine, rev2, [ - {'name': test1, 'execution_time': [2.0]}, - {'name': test2, 'execution_time': [2.0]}, - ]) - - shared_fc = submit_fieldchange(self.client, self.app, machine, - test1, 'execution_time', - rev1, rev2) - unique_fc = submit_fieldchange(self.client, self.app, machine, - test2, 'execution_time', - rev1, rev2) - - target = submit_regression( - self.client, self.app, - [shared_fc['uuid'], unique_fc['uuid']]) - source = submit_regression( - self.client, self.app, [shared_fc['uuid']]) - - target_uuid = target['uuid'] - source_uuid = source['uuid'] + machine = f'add-m-{tag}' + test = f'add/test/{tag}' + submit_run(self.client, machine, f'add-rev-{tag}', + [{'name': test, 'execution_time': [1.0]}]) headers = _triage_headers(self.app) resp = self.client.post( - PREFIX + f'/regressions/{target_uuid}/merge', - json={'source_regression_uuids': [source_uuid]}, + PREFIX + f'/regressions/{reg_uuid}/indicators', + json={'indicators': [ + {'machine': machine, 'test': test, + 'metric': 'execution_time'} + ]}, headers=headers, ) self.assertEqual(resp.status_code, 200) data = resp.get_json() + self.assertIn('indicators', data) self.assertEqual(len(data['indicators']), 2) - def test_merge_into_self_400(self): - reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) - headers = _triage_headers(self.app) - resp = self.client.post( - PREFIX + f'/regressions/{reg_uuid}/merge', - json={'source_regression_uuids': [reg_uuid]}, - headers=headers, - ) - self.assertEqual(resp.status_code, 400) + def test_add_duplicate_silently_ignored(self): + """Adding a duplicate indicator is silently ignored.""" + reg_uuid, ind_uuids = _setup_regression_with_indicators( + self.client, self.app, 1) - def test_merge_missing_body_422(self): - reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) - headers = _triage_headers(self.app) - resp = self.client.post( - PREFIX + f'/regressions/{reg_uuid}/merge', - json={}, - headers=headers, - ) - self.assertEqual(resp.status_code, 422) + # Get the existing indicator details + resp = self.client.get(PREFIX + f'/regressions/{reg_uuid}') + data = resp.get_json() + existing = data['indicators'][0] - def test_merge_nonexistent_source_404(self): - reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) headers = _triage_headers(self.app) - resp = self.client.post( - PREFIX + f'/regressions/{reg_uuid}/merge', - json={'source_regression_uuids': ['nonexistent-uuid']}, + resp2 = self.client.post( + PREFIX + f'/regressions/{reg_uuid}/indicators', + json={'indicators': [ + {'machine': existing['machine'], 'test': existing['test'], + 'metric': existing['metric']} + ]}, headers=headers, ) - self.assertEqual(resp.status_code, 404) + self.assertEqual(resp2.status_code, 200) + data2 = resp2.get_json() + self.assertEqual(len(data2['indicators']), 1) - def test_merge_nonexistent_target_404(self): + def test_add_nonexistent_machine_404(self): + reg_uuid, _ = _setup_regression_with_indicators( + self.client, self.app, 1) headers = _triage_headers(self.app) resp = self.client.post( - PREFIX + '/regressions/nonexistent-uuid/merge', - json={'source_regression_uuids': ['also-nonexistent']}, + PREFIX + f'/regressions/{reg_uuid}/indicators', + json={'indicators': [ + {'machine': 'nonexistent-machine-xyz', + 'test': 'some/test', 'metric': 'execution_time'} + ]}, headers=headers, ) self.assertEqual(resp.status_code, 404) - def test_merge_no_auth_401(self): - reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) - resp = self.client.post( - PREFIX + f'/regressions/{reg_uuid}/merge', - json={'source_regression_uuids': ['x']}, - ) - self.assertEqual(resp.status_code, 401) - - -# ========================================================================== -# Regression Split Tests -# ========================================================================== - -class TestRegressionSplit(unittest.TestCase): - @classmethod - def setUpClass(cls): - super().setUpClass() - cls.app = create_app(sys.argv[1]) - cls.client = create_client(cls.app) + def test_add_nonexistent_test_404(self): + reg_uuid, _ = _setup_regression_with_indicators( + self.client, self.app, 1) + # Get the existing indicator machine name + resp = self.client.get(PREFIX + f'/regressions/{reg_uuid}') + existing_machine = resp.get_json()['indicators'][0]['machine'] - def test_split_regression(self): - """Split one field change into a new regression.""" - reg_uuid, fc_uuids = _setup_regression_with_indicators(self.client, self.app, 3) headers = _triage_headers(self.app) - - resp = self.client.post( - PREFIX + f'/regressions/{reg_uuid}/split', - json={'field_change_uuids': [fc_uuids[0]]}, + resp2 = self.client.post( + PREFIX + f'/regressions/{reg_uuid}/indicators', + json={'indicators': [ + {'machine': existing_machine, + 'test': 'nonexistent/test/xyz', + 'metric': 'execution_time'} + ]}, headers=headers, ) - self.assertEqual(resp.status_code, 201) - data = resp.get_json() - self.assertIn('uuid', data) - self.assertNotEqual(data['uuid'], reg_uuid) - self.assertEqual(len(data['indicators']), 1) - self.assertEqual(data['indicators'][0]['field_change_uuid'], - fc_uuids[0]) + self.assertEqual(resp2.status_code, 404) - # Original regression should have 2 remaining indicators - resp2 = self.client.get(PREFIX + f'/regressions/{reg_uuid}') - self.assertEqual(resp2.status_code, 200) - data2 = resp2.get_json() - self.assertEqual(len(data2['indicators']), 2) + def test_add_unknown_metric_400(self): + reg_uuid, _ = _setup_regression_with_indicators( + self.client, self.app, 1) + resp = self.client.get(PREFIX + f'/regressions/{reg_uuid}') + existing = resp.get_json()['indicators'][0] - def test_split_all_indicators_400(self): - """Cannot split ALL indicators -- would leave source empty.""" - reg_uuid, fc_uuids = _setup_regression_with_indicators(self.client, self.app, 2) headers = _triage_headers(self.app) - - resp = self.client.post( - PREFIX + f'/regressions/{reg_uuid}/split', - json={'field_change_uuids': fc_uuids}, + resp2 = self.client.post( + PREFIX + f'/regressions/{reg_uuid}/indicators', + json={'indicators': [ + {'machine': existing['machine'], + 'test': existing['test'], + 'metric': 'nonexistent_metric'} + ]}, headers=headers, ) - self.assertEqual(resp.status_code, 400) + self.assertEqual(resp2.status_code, 400) - def test_split_missing_body_422(self): - reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 2) - headers = _triage_headers(self.app) + def test_add_indicator_no_auth_401(self): + reg_uuid, _ = _setup_regression_with_indicators( + self.client, self.app, 1) resp = self.client.post( - PREFIX + f'/regressions/{reg_uuid}/split', - json={}, - headers=headers, + PREFIX + f'/regressions/{reg_uuid}/indicators', + json={'indicators': [ + {'machine': 'x', 'test': 'y', 'metric': 'z'} + ]}, ) - self.assertEqual(resp.status_code, 422) + self.assertEqual(resp.status_code, 401) - def test_split_fc_not_in_regression_400(self): - """Splitting a field change that's not in this regression -> 400.""" - reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 2) - other_fc_uuid = _setup_fieldchange(self.client, self.app) + def test_add_empty_list_422(self): + """POST with empty indicators list returns 422.""" + reg_uuid, _ = _setup_regression_with_indicators( + self.client, self.app, 1) headers = _triage_headers(self.app) resp = self.client.post( - PREFIX + f'/regressions/{reg_uuid}/split', - json={'field_change_uuids': [other_fc_uuid]}, + PREFIX + f'/regressions/{reg_uuid}/indicators', + json={'indicators': []}, headers=headers, ) - self.assertEqual(resp.status_code, 400) + self.assertEqual(resp.status_code, 422) - def test_split_nonexistent_regression_404(self): + def test_remove_indicator(self): + """Remove indicators via batch DELETE.""" + reg_uuid, ind_uuids = _setup_regression_with_indicators( + self.client, self.app, 2) headers = _triage_headers(self.app) - resp = self.client.post( - PREFIX + '/regressions/nonexistent-uuid/split', - json={'field_change_uuids': ['x']}, + resp = self.client.delete( + PREFIX + f'/regressions/{reg_uuid}/indicators', + json={'indicator_uuids': [ind_uuids[0]]}, headers=headers, ) - self.assertEqual(resp.status_code, 404) - - def test_split_no_auth_401(self): - reg_uuid, fc_uuids = _setup_regression_with_indicators(self.client, self.app, 2) - resp = self.client.post( - PREFIX + f'/regressions/{reg_uuid}/split', - json={'field_change_uuids': [fc_uuids[0]]}, - ) - self.assertEqual(resp.status_code, 401) - - -# ========================================================================== -# Regression Indicators Tests -# ========================================================================== - -class TestRegressionIndicators(unittest.TestCase): - @classmethod - def setUpClass(cls): - super().setUpClass() - cls.app = create_app(sys.argv[1]) - cls.client = create_client(cls.app) - - def test_list_indicators(self): - reg_uuid, fc_uuids = _setup_regression_with_indicators(self.client, self.app, 2) - resp = self.client.get( - PREFIX + f'/regressions/{reg_uuid}/indicators') self.assertEqual(resp.status_code, 200) data = resp.get_json() - self.assertIn('items', data) - self.assertEqual(len(data['items']), 2) - self.assertIn('cursor', data) - - def test_list_indicators_nonexistent_regression_404(self): - resp = self.client.get( - PREFIX + '/regressions/nonexistent-uuid/indicators') - self.assertEqual(resp.status_code, 404) + self.assertEqual(len(data['indicators']), 1) - def test_add_indicator(self): - reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) - fc_uuid = _setup_fieldchange(self.client, self.app) + def test_remove_multiple_batch(self): + """Remove 2 of 3 indicators in one batch.""" + reg_uuid, ind_uuids = _setup_regression_with_indicators( + self.client, self.app, 3) headers = _triage_headers(self.app) - - resp = self.client.post( + resp = self.client.delete( PREFIX + f'/regressions/{reg_uuid}/indicators', - json={'field_change_uuid': fc_uuid}, + json={'indicator_uuids': ind_uuids[:2]}, headers=headers, ) - self.assertEqual(resp.status_code, 201) + self.assertEqual(resp.status_code, 200) data = resp.get_json() - self.assertEqual(data['field_change_uuid'], fc_uuid) - - # Verify it appears in the indicators list - resp2 = self.client.get( - PREFIX + f'/regressions/{reg_uuid}/indicators') - data2 = resp2.get_json() - self.assertEqual(len(data2['items']), 2) - - def test_add_duplicate_indicator_409(self): - reg_uuid, fc_uuids = _setup_regression_with_indicators(self.client, self.app, 1) - headers = _triage_headers(self.app) - resp = self.client.post( - PREFIX + f'/regressions/{reg_uuid}/indicators', - json={'field_change_uuid': fc_uuids[0]}, - headers=headers, - ) - self.assertEqual(resp.status_code, 409) + self.assertEqual(len(data['indicators']), 1) - def test_add_nonexistent_fc_404(self): - reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) + def test_remove_unknown_uuid_silently_ignored(self): + """Unknown UUIDs in batch remove are silently ignored.""" + reg_uuid, ind_uuids = _setup_regression_with_indicators( + self.client, self.app, 1) headers = _triage_headers(self.app) - resp = self.client.post( + resp = self.client.delete( PREFIX + f'/regressions/{reg_uuid}/indicators', - json={'field_change_uuid': 'nonexistent-uuid'}, + json={'indicator_uuids': ['nonexistent-uuid-xyz']}, headers=headers, ) - self.assertEqual(resp.status_code, 404) + self.assertEqual(resp.status_code, 200) + data = resp.get_json() + self.assertEqual(len(data['indicators']), 1) - def test_add_indicator_no_auth_401(self): - reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) - resp = self.client.post( + def test_remove_no_auth_401(self): + reg_uuid, ind_uuids = _setup_regression_with_indicators( + self.client, self.app, 1) + resp = self.client.delete( PREFIX + f'/regressions/{reg_uuid}/indicators', - json={'field_change_uuid': 'x'}, + json={'indicator_uuids': [ind_uuids[0]]}, ) self.assertEqual(resp.status_code, 401) - def test_remove_indicator(self): - reg_uuid, fc_uuids = _setup_regression_with_indicators(self.client, self.app, 2) + def test_remove_empty_list_422(self): + """DELETE with empty indicator_uuids list returns 422.""" + reg_uuid, _ = _setup_regression_with_indicators( + self.client, self.app, 1) headers = _triage_headers(self.app) resp = self.client.delete( - PREFIX + f'/regressions/{reg_uuid}/indicators/{fc_uuids[0]}', - headers=headers, - ) - self.assertEqual(resp.status_code, 204) - - # Verify indicator is removed - resp2 = self.client.get( - PREFIX + f'/regressions/{reg_uuid}/indicators') - data2 = resp2.get_json() - self.assertEqual(len(data2['items']), 1) - - def test_remove_nonexistent_indicator_404(self): - reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) - headers = _triage_headers(self.app) - resp = self.client.delete( - PREFIX + f'/regressions/{reg_uuid}/indicators/nonexistent-fc-uuid', - headers=headers, - ) - self.assertEqual(resp.status_code, 404) - - def test_remove_indicator_not_linked_404(self): - """Remove a field change that exists but is not linked.""" - reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) - other_fc_uuid = _setup_fieldchange(self.client, self.app) - headers = _triage_headers(self.app) - resp = self.client.delete( - PREFIX + f'/regressions/{reg_uuid}/indicators/{other_fc_uuid}', + PREFIX + f'/regressions/{reg_uuid}/indicators', + json={'indicator_uuids': []}, headers=headers, ) - self.assertEqual(resp.status_code, 404) - - def test_invalid_cursor_returns_400(self): - """An invalid cursor string should return 400.""" - reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) - resp = self.client.get( - PREFIX + f'/regressions/{reg_uuid}/indicators' - '?cursor=not-a-valid-cursor!!!') - self.assertEqual(resp.status_code, 400) + self.assertEqual(resp.status_code, 422) class TestRegressionZPagination(unittest.TestCase): @@ -1018,7 +1152,8 @@ def setUpClass(cls): cls.client = create_client(cls.app) cls._reg_uuids = [] for _ in range(5): - reg_uuid, _ = _setup_regression_with_indicators(cls.client, cls.app, 1) + reg_uuid, _ = _setup_regression_with_indicators( + cls.client, cls.app, 1) cls._reg_uuids.append(reg_uuid) def _collect_all_pages(self): @@ -1039,32 +1174,6 @@ def test_no_duplicate_items_across_pages(self): self.assertEqual(len(uuids), len(set(uuids))) -class TestRegressionZIndicatorPagination(unittest.TestCase): - """Exhaustive cursor pagination tests for GET /api/v5/{ts}/regressions/{uuid}/indicators.""" - @classmethod - def setUpClass(cls): - super().setUpClass() - cls.app = create_app(sys.argv[1]) - cls.client = create_client(cls.app) - cls._reg_uuid, cls._fc_uuids = _setup_regression_with_indicators( - cls.client, cls.app, num_indicators=5) - - def _collect_all_pages(self): - url = PREFIX + f'/regressions/{self._reg_uuid}/indicators?limit=2' - return collect_all_pages(self, self.client, url) - - def test_pagination_collects_all_items(self): - """Paginating through all pages collects all 5 indicators.""" - all_items = self._collect_all_pages() - self.assertEqual(len(all_items), 5) - - def test_no_duplicate_items_across_pages(self): - """No duplicate field change UUIDs across pages.""" - all_items = self._collect_all_pages() - fc_uuids = [item['field_change_uuid'] for item in all_items] - self.assertEqual(len(fc_uuids), len(set(fc_uuids))) - - class TestRegressionUnknownParams(unittest.TestCase): """Test that unknown query parameters are rejected with 400.""" @classmethod @@ -1080,17 +1189,12 @@ def test_regressions_list_unknown_param_returns_400(self): self.assertIn('bogus', data['error']['message']) def test_regression_detail_unknown_param_returns_400(self): - reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) + reg_uuid, _ = _setup_regression_with_indicators( + self.client, self.app, 1) resp = self.client.get( PREFIX + f'/regressions/{reg_uuid}?bogus=1') self.assertEqual(resp.status_code, 400) - def test_regression_indicators_unknown_param_returns_400(self): - reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) - resp = self.client.get( - PREFIX + f'/regressions/{reg_uuid}/indicators?bogus=1') - self.assertEqual(resp.status_code, 400) - if __name__ == '__main__': unittest.main(argv=[sys.argv[0]], exit=True) diff --git a/tests/server/api/v5/v5_test_helpers.py b/tests/server/api/v5/v5_test_helpers.py index 2e9303e7e..bc5ee4e8a 100644 --- a/tests/server/api/v5/v5_test_helpers.py +++ b/tests/server/api/v5/v5_test_helpers.py @@ -5,7 +5,7 @@ - ``create_client`` -- Return a Flask test client - Auth helpers for creating API keys and headers - Data creation helpers using V5TestSuiteDB methods -- API-based fixture helpers (submit_run, submit_fieldchange, etc.) +- API-based fixture helpers (submit_run, submit_regression, etc.) """ import datetime @@ -107,19 +107,17 @@ def create_sample(session, ts, run, test, **field_values): return samples[0] -def create_fieldchange(session, ts, start_commit, end_commit, machine, test, - field_name, old_value=1.0, new_value=2.0): - """Create a FieldChange via V5TestSuiteDB and return it.""" - return ts.create_field_change( - session, machine, test, field_name, - start_commit, end_commit, old_value, new_value) - - def create_regression(session, ts, title='Test Regression', - state=0, field_changes=None): - """Create a Regression (optionally with indicators) and return it.""" - fc_ids = [fc.id for fc in field_changes] if field_changes else [] - return ts.create_regression(session, title, fc_ids, state=state) + state=0, indicators=None, commit=None, + notes=None, bug=None): + """Create a Regression (optionally with indicators) and return it. + + *indicators* is a list of dicts with keys machine_id, test_id, metric. + """ + indicator_list = indicators or [] + return ts.create_regression( + session, title, indicator_list, + state=state, commit=commit, notes=notes, bug=bug) # --------------------------------------------------------------------------- @@ -186,29 +184,50 @@ def submit_run(client, machine_name, commit, tests, return resp.get_json() -def submit_fieldchange(client, app, machine, test, metric, - start_commit, end_commit, - old_value=10.0, new_value=20.0, - testsuite='nts'): - """Create a field change via POST and return response JSON.""" - body = { - 'machine': machine, 'test': test, 'metric': metric, - 'old_value': old_value, 'new_value': new_value, - 'start_commit': start_commit, 'end_commit': end_commit, - } - resp = client.post(f'/api/v5/{testsuite}/field-changes', - json=body, headers=admin_headers()) - assert resp.status_code == 201, ( - f"FC creation failed: {resp.get_json()}") - return resp.get_json() - - -def submit_regression(client, app, fc_uuids, state='active', +def submit_regression(client, app, indicators=None, state='active', + title=None, commit=None, notes=None, bug=None, testsuite='nts'): - """Create a regression via POST and return response JSON.""" - body = {'field_change_uuids': fc_uuids, 'state': state} + """Create a regression via POST and return response JSON. + + *indicators* is a list of {machine, test, metric} dicts. + """ + body = {'state': state} + if indicators: + body['indicators'] = indicators + if title: + body['title'] = title + if commit: + body['commit'] = commit + if notes: + body['notes'] = notes + if bug: + body['bug'] = bug resp = client.post(f'/api/v5/{testsuite}/regressions', json=body, headers=admin_headers()) assert resp.status_code == 201, ( f"Regression creation failed: {resp.get_json()}") return resp.get_json() + + +def submit_indicator_add(client, app, regression_uuid, indicators, + testsuite='nts'): + """Add indicators to a regression via POST and return response JSON.""" + resp = client.post( + f'/api/v5/{testsuite}/regressions/{regression_uuid}/indicators', + json={'indicators': indicators}, + headers=admin_headers()) + assert resp.status_code == 200, ( + f"Indicator add failed: {resp.get_json()}") + return resp.get_json() + + +def submit_indicator_remove(client, app, regression_uuid, indicator_uuids, + testsuite='nts'): + """Remove indicators from a regression via DELETE and return response JSON.""" + resp = client.delete( + f'/api/v5/{testsuite}/regressions/{regression_uuid}/indicators', + json={'indicator_uuids': indicator_uuids}, + headers=admin_headers()) + assert resp.status_code == 200, ( + f"Indicator remove failed: {resp.get_json()}") + return resp.get_json() From a5effa160815564c59e0274fc7a51d87acb3bfe5 Mon Sep 17 00:00:00 2001 From: Louis Dionne Date: Wed, 15 Apr 2026 12:18:58 -0400 Subject: [PATCH 069/143] [API+Docs] Add missing OpenAPI schemas and update llms.txt Wire @blp.arguments for request body documentation on POST/PATCH commits and POST runs, so Swagger UI shows their schemas. Add @blp.response(204) to DELETE test-suites. Add metadata descriptions to fields missing them across 6 schema files. Update llms.txt with missing endpoints (samples, test detail, trends, field-changes/regressions create, test suite create, API key CRUD), a run submission body example, query optional parameters, and a trends workflow. Co-Authored-By: Claude Opus 4.6 (1M context) --- lnt/server/api/v5/endpoints/agents.py | 40 +++++++---- lnt/server/api/v5/endpoints/commits.py | 32 ++++----- lnt/server/api/v5/endpoints/runs.py | 25 ++----- lnt/server/api/v5/endpoints/test_suites.py | 1 + lnt/server/api/v5/schemas/admin.py | 30 ++++++-- lnt/server/api/v5/schemas/commits.py | 43 +++++++++++- lnt/server/api/v5/schemas/common.py | 18 ++--- lnt/server/api/v5/schemas/machines.py | 10 ++- lnt/server/api/v5/schemas/regressions.py | 30 ++++++-- lnt/server/api/v5/schemas/runs.py | 80 ++++++++++++++++++++++ lnt/server/ui/v5/views.py | 1 - tests/server/api/v5/test_agents.py | 1 - tests/server/api/v5/test_commits.py | 12 ++-- tests/server/api/v5/test_runs.py | 35 ++++------ 14 files changed, 251 insertions(+), 107 deletions(-) diff --git a/lnt/server/api/v5/endpoints/agents.py b/lnt/server/api/v5/endpoints/agents.py index c8f1958d6..365e3af61 100644 --- a/lnt/server/api/v5/endpoints/agents.py +++ b/lnt/server/api/v5/endpoints/agents.py @@ -70,26 +70,25 @@ GET /api/v5/{ts}/runs List runs POST /api/v5/{ts}/runs Submit a run GET /api/v5/{ts}/runs/{uuid} Run detail + GET /api/v5/{ts}/runs/{uuid}/samples Samples for a run GET /api/v5/{ts}/tests List tests + GET /api/v5/{ts}/tests/{name} Test detail POST /api/v5/{ts}/query Query time-series data + POST /api/v5/{ts}/trends Aggregated trend data (geomean) GET /api/v5/{ts}/regressions List regressions + POST /api/v5/{ts}/regressions Create regression ### Global Endpoints GET /api/v5/test-suites List all test suites GET /api/v5/test-suites/{name} Suite detail (schema + metrics) + POST /api/v5/test-suites Create test suite (admin) GET /api/v5/admin/api-keys List API keys (admin) + POST /api/v5/admin/api-keys Create API key (admin) + DELETE /api/v5/admin/api-keys/{prefix} Revoke API key (admin) -The endpoints above cover the most common read operations. The API also -supports write operations (creating/updating/deleting machines, commits, -runs, regressions, test suites, and API keys) which require -appropriate authentication scopes. See the OpenAPI spec or Swagger UI for -the complete endpoint list including all write operations. - -### Interactive Documentation - - OpenAPI spec: /api/v5/openapi/openapi.json - Swagger UI: /api/v5/openapi/swagger-ui +Full endpoint list including all PATCH/DELETE operations: + /api/v5/openapi/swagger-ui ### Pagination @@ -105,10 +104,19 @@ 2. Query performance history: POST /api/v5/{ts}/query with { "metric": "execution_time", "machine": "machine-name", "test": ["test/name"] } to get time-series data points. - -3. Submit a run: POST /api/v5/{ts}/runs with a JSON payload containing - format_version "5", machine, commit, and tests. Requires a token with - "submit" scope. + Optional filters: after_commit, before_commit, after_time, before_time. + Optional sort: "test", "commit", "submitted_at" (prefix with - for desc). + +3. Submit a run: POST /api/v5/{ts}/runs with a JSON body: + { "format_version": "5", + "machine": { "name": "machine-name" }, + "commit": "abc123", + "tests": [ + { "name": "test/name", "execution_time": 1.23, "compile_time": 0.45 }, + { "name": "test/name", "execution_time": [1.0, 2.0] } + ] } + Metric values can be scalars or arrays (arrays create multiple samples). + Requires a token with "submit" scope. 4. Check for regressions: GET /api/v5/{ts}/regressions?state=detected to find new regressions. PATCH to update state, title, bug link, notes, @@ -118,6 +126,10 @@ the commit detail with previous/next navigation links. Use PATCH /api/v5/{ts}/commits/{value} to assign an ordinal for time-series ordering. + +6. Aggregated trends: POST /api/v5/{ts}/trends with + { "metric": "execution_time", "machine": ["m1", "m2"] } to get + geomean-aggregated performance per (machine, commit) pair. """ _ETAG = hashlib.md5(LLMS_TEXT.encode()).hexdigest() diff --git a/lnt/server/api/v5/endpoints/commits.py b/lnt/server/api/v5/endpoints/commits.py index dafe71f9a..047673dca 100644 --- a/lnt/server/api/v5/endpoints/commits.py +++ b/lnt/server/api/v5/endpoints/commits.py @@ -7,7 +7,7 @@ DELETE /api/v5/{ts}/commits/{value} -- Delete commit (cascade) """ -from flask import g, jsonify, request +from flask import g, jsonify from flask.views import MethodView from flask_smorest import Blueprint from sqlalchemy import or_ @@ -21,9 +21,11 @@ make_paginated_response, ) from ..schemas.commits import ( + CommitCreateSchema, CommitDetailQuerySchema, CommitDetailSchema, CommitListQuerySchema, + CommitUpdateSchema, PaginatedCommitResponseSchema, ) @@ -153,30 +155,25 @@ def get(self, query_args, testsuite): return jsonify(make_paginated_response(serialized, next_cursor)) @require_scope('submit') + @blp.arguments(CommitCreateSchema) @blp.response(201, CommitDetailSchema) - def post(self, testsuite): + def post(self, body, testsuite): """Create a commit explicitly.""" ts = g.ts session = g.db_session - data = request.get_json(silent=True) - if not data: - abort_with_error(400, "Request body must be valid JSON") - - commit_str = data.get('commit') - if not commit_str: - abort_with_error(400, "Missing required field: 'commit'") + commit_str = body['commit'] # Check if commit already exists. existing = ts.get_commit(session, commit=commit_str) if existing is not None: abort_with_error(409, "Commit '%s' already exists" % commit_str) - metadata = _extract_commit_fields(data, ts) + metadata = _extract_commit_fields(body, ts) commit_obj = ts.get_or_create_commit(session, commit_str, **metadata) # Set ordinal if provided. - ordinal = data.get('ordinal') + ordinal = body.get('ordinal') if ordinal is not None: ts.update_commit(session, commit_obj, ordinal=ordinal) @@ -213,8 +210,9 @@ def get(self, query_args, testsuite, commit_value): return add_etag_to_response(jsonify(data), data) @require_scope('manage') + @blp.arguments(CommitUpdateSchema) @blp.response(200, CommitDetailSchema) - def patch(self, testsuite, commit_value): + def patch(self, body, testsuite, commit_value): """Update commit ordinal and/or commit_fields.""" ts = g.ts session = g.db_session @@ -223,20 +221,16 @@ def patch(self, testsuite, commit_value): if commit_obj is None: abort_with_error(404, "Commit '%s' not found" % commit_value) - data = request.get_json(silent=True) - if not data: - abort_with_error(400, "Request body must be valid JSON") - # Update ordinal if provided. - if 'ordinal' in data: - ordinal_val = data['ordinal'] + if 'ordinal' in body: + ordinal_val = body['ordinal'] if ordinal_val is None: ts.update_commit(session, commit_obj, clear_ordinal=True) else: ts.update_commit(session, commit_obj, ordinal=ordinal_val) # Update commit_fields. - field_updates = _extract_commit_fields(data, ts, skip=('ordinal',)) + field_updates = _extract_commit_fields(body, ts, skip=('ordinal',)) if field_updates: ts.update_commit(session, commit_obj, **field_updates) diff --git a/lnt/server/api/v5/endpoints/runs.py b/lnt/server/api/v5/endpoints/runs.py index c272469f3..21713a815 100644 --- a/lnt/server/api/v5/endpoints/runs.py +++ b/lnt/server/api/v5/endpoints/runs.py @@ -6,9 +6,7 @@ DELETE /api/v5/{ts}/runs/{uuid} -- Delete run """ -import json - -from flask import g, jsonify, make_response, request +from flask import g, jsonify, make_response from flask.views import MethodView from flask_smorest import Blueprint from sqlalchemy.orm import joinedload @@ -25,6 +23,7 @@ PaginatedRunResponseSchema, RunListQuerySchema, RunResponseSchema, + RunSubmitBodySchema, RunSubmitQuerySchema, RunSubmitResponseSchema, ) @@ -102,8 +101,9 @@ def get(self, query_args, testsuite): @require_scope('submit') @blp.arguments(RunSubmitQuerySchema, location="query") + @blp.arguments(RunSubmitBodySchema) @blp.response(201, RunSubmitResponseSchema) - def post(self, query_args, testsuite): + def post(self, query_args, body, testsuite): """Submit a new run. Accepts the v5 JSON report format (format_version '5'). @@ -114,20 +114,7 @@ def post(self, query_args, testsuite): ts = g.ts session = g.db_session - data = request.get_data(as_text=True) - if not data or not data.strip(): - abort_with_error(400, - "Request body must be a non-empty JSON payload") - - try: - parsed = json.loads(data) - except ValueError as exc: - abort_with_error(400, "Request body is not valid JSON: %s" % exc) - if not isinstance(parsed, dict): - abort_with_error(400, "Request body must be a JSON object, " - "not %s" % type(parsed).__name__) - - version = parsed.get('format_version') + version = body.get('format_version') if version is None: abort_with_error(400, "v5 API requires format_version '5', " "but it is missing") @@ -137,7 +124,7 @@ def post(self, query_args, testsuite): try: run = ts.import_run( - session, parsed, + session, body, machine_strategy=query_args['on_machine_conflict']) except ValueError as exc: abort_with_error(400, str(exc)) diff --git a/lnt/server/api/v5/endpoints/test_suites.py b/lnt/server/api/v5/endpoints/test_suites.py index 0f3857c95..90445d708 100644 --- a/lnt/server/api/v5/endpoints/test_suites.py +++ b/lnt/server/api/v5/endpoints/test_suites.py @@ -132,6 +132,7 @@ def get(self, query_args, suite_name): @require_scope('manage') @blp.arguments(TestSuiteDeleteQuerySchema, location='query') + @blp.response(204) def delete(self, query_args, suite_name): """Delete a test suite and all its data (irreversible). diff --git a/lnt/server/api/v5/schemas/admin.py b/lnt/server/api/v5/schemas/admin.py index ca3b9b577..d2fee00cb 100644 --- a/lnt/server/api/v5/schemas/admin.py +++ b/lnt/server/api/v5/schemas/admin.py @@ -66,12 +66,30 @@ class APIKeyItemSchema(BaseSchema): Never includes the key hash or the raw token. """ - prefix = ma.fields.String(required=True) - name = ma.fields.String(required=True) - scope = ma.fields.String(required=True) - created_at = ma.fields.DateTime(required=True) - last_used_at = ma.fields.DateTime(allow_none=True) - is_active = ma.fields.Boolean(required=True) + prefix = ma.fields.String( + required=True, + metadata={'description': 'First 8 characters of the token (identifier)'}, + ) + name = ma.fields.String( + required=True, + metadata={'description': 'Human-readable key name'}, + ) + scope = ma.fields.String( + required=True, + metadata={'description': 'Granted scope level'}, + ) + created_at = ma.fields.DateTime( + required=True, + metadata={'description': 'When the key was created'}, + ) + last_used_at = ma.fields.DateTime( + allow_none=True, + metadata={'description': 'When the key was last used'}, + ) + is_active = ma.fields.Boolean( + required=True, + metadata={'description': 'Whether the key is active (not revoked)'}, + ) class APIKeyListResponseSchema(BaseSchema): diff --git a/lnt/server/api/v5/schemas/commits.py b/lnt/server/api/v5/schemas/commits.py index 05e57c2c0..e566c0dd0 100644 --- a/lnt/server/api/v5/schemas/commits.py +++ b/lnt/server/api/v5/schemas/commits.py @@ -52,11 +52,18 @@ class CommitNeighborSchema(BaseSchema): class CommitDetailSchema(BaseSchema): """Full commit detail including previous/next neighbors.""" - commit = ma.fields.String(required=True) - ordinal = ma.fields.Integer(allow_none=True) + commit = ma.fields.String( + required=True, + metadata={'description': 'Unique commit identifier (e.g. git SHA)'}, + ) + ordinal = ma.fields.Integer( + allow_none=True, + metadata={'description': 'Optional integer for total ordering'}, + ) fields = ma.fields.Dict( keys=ma.fields.String(), values=ma.fields.Raw(allow_none=True), + metadata={'description': 'Commit field values defined by the test suite schema'}, ) previous_commit = ma.fields.Nested( CommitNeighborSchema, allow_none=True, @@ -93,3 +100,35 @@ class CommitListQuerySchema(CursorPaginationQuerySchema): class CommitDetailQuerySchema(BaseQuerySchema): """Query parameters for GET /commits/{value}.""" pass + + +# --------------------------------------------------------------------------- +# Request body schemas +# --------------------------------------------------------------------------- + +class CommitCreateSchema(BaseSchema): + """Request body for POST /commits.""" + class Meta: + unknown = ma.INCLUDE + + commit = ma.fields.String( + required=True, + metadata={'description': 'Unique commit identifier (e.g. git SHA)'}, + ) + ordinal = ma.fields.Integer( + load_default=None, + allow_none=True, + metadata={'description': 'Optional integer for total ordering'}, + ) + + +class CommitUpdateSchema(BaseSchema): + """Request body for PATCH /commits/{value}.""" + class Meta: + unknown = ma.INCLUDE + + ordinal = ma.fields.Integer( + load_default=None, + allow_none=True, + metadata={'description': 'Integer for total ordering, or null to clear'}, + ) diff --git a/lnt/server/api/v5/schemas/common.py b/lnt/server/api/v5/schemas/common.py index d6605a384..a87488d1f 100644 --- a/lnt/server/api/v5/schemas/common.py +++ b/lnt/server/api/v5/schemas/common.py @@ -50,12 +50,12 @@ class PaginatedResponseSchema(BaseSchema): class TestSuiteLinksSchema(BaseSchema): """Links to resources within a test suite.""" - machines = ma.fields.String() - commits = ma.fields.String() - runs = ma.fields.String() - tests = ma.fields.String() - regressions = ma.fields.String() - query = ma.fields.String() + machines = ma.fields.String(metadata={'description': 'URL for machines list'}) + commits = ma.fields.String(metadata={'description': 'URL for commits list'}) + runs = ma.fields.String(metadata={'description': 'URL for runs list'}) + tests = ma.fields.String(metadata={'description': 'URL for tests list'}) + regressions = ma.fields.String(metadata={'description': 'URL for regressions list'}) + query = ma.fields.String(metadata={'description': 'URL for time-series query endpoint'}) class TestSuiteDiscoverySchema(BaseSchema): @@ -66,9 +66,9 @@ class TestSuiteDiscoverySchema(BaseSchema): class DiscoveryLinksSchema(BaseSchema): """Top-level links in the discovery response.""" - openapi = ma.fields.String() - swagger_ui = ma.fields.String() - test_suites = ma.fields.String() + openapi = ma.fields.String(metadata={'description': 'URL for OpenAPI JSON spec'}) + swagger_ui = ma.fields.String(metadata={'description': 'URL for Swagger UI'}) + test_suites = ma.fields.String(metadata={'description': 'URL for test suites list'}) class DiscoveryResponseSchema(BaseSchema): diff --git a/lnt/server/api/v5/schemas/machines.py b/lnt/server/api/v5/schemas/machines.py index 67d8893a3..05d320acb 100644 --- a/lnt/server/api/v5/schemas/machines.py +++ b/lnt/server/api/v5/schemas/machines.py @@ -52,7 +52,10 @@ class MachineUpdateSchema(BaseSchema): class MachineResponseSchema(BaseSchema): """Schema for a single machine in responses.""" - name = ma.fields.String(required=True) + name = ma.fields.String( + required=True, + metadata={'description': 'Machine name'}, + ) info = ma.fields.Dict( keys=ma.fields.String(), values=ma.fields.String(), @@ -65,7 +68,10 @@ class MachineResponseSchema(BaseSchema): class MachineRunResponseSchema(BaseSchema): """Schema for a run in the machine runs sub-resource.""" - uuid = ma.fields.String(required=True) + uuid = ma.fields.String( + required=True, + metadata={'description': 'Server-generated UUID for the run'}, + ) commit = ma.fields.String( allow_none=True, metadata={'description': 'Commit string for this run'}, diff --git a/lnt/server/api/v5/schemas/regressions.py b/lnt/server/api/v5/schemas/regressions.py index a083a17ff..5ffeb2843 100644 --- a/lnt/server/api/v5/schemas/regressions.py +++ b/lnt/server/api/v5/schemas/regressions.py @@ -180,9 +180,18 @@ class RegressionUpdateSchema(BaseSchema): class RegressionListItemSchema(BaseSchema): """Schema for a regression in list responses.""" - uuid = ma.fields.String(required=True) - title = ma.fields.String(allow_none=True) - bug = ma.fields.String(allow_none=True) + uuid = ma.fields.String( + required=True, + metadata={'description': 'Regression UUID'}, + ) + title = ma.fields.String( + allow_none=True, + metadata={'description': 'Regression title'}, + ) + bug = ma.fields.String( + allow_none=True, + metadata={'description': 'Bug tracker URL'}, + ) state = ma.fields.String( required=True, metadata={'description': 'Regression state', 'enum': VALID_STATES}, @@ -201,9 +210,18 @@ class RegressionListItemSchema(BaseSchema): class RegressionDetailSchema(BaseSchema): """Schema for a single regression detail response.""" - uuid = ma.fields.String(required=True) - title = ma.fields.String(allow_none=True) - bug = ma.fields.String(allow_none=True) + uuid = ma.fields.String( + required=True, + metadata={'description': 'Regression UUID'}, + ) + title = ma.fields.String( + allow_none=True, + metadata={'description': 'Regression title'}, + ) + bug = ma.fields.String( + allow_none=True, + metadata={'description': 'Bug tracker URL'}, + ) notes = ma.fields.String( allow_none=True, metadata={'description': 'Investigation notes'}, diff --git a/lnt/server/api/v5/schemas/runs.py b/lnt/server/api/v5/schemas/runs.py index 75ebf1731..ee5a629ab 100644 --- a/lnt/server/api/v5/schemas/runs.py +++ b/lnt/server/api/v5/schemas/runs.py @@ -6,6 +6,86 @@ from .common import BaseQuerySchema, CursorPaginationQuerySchema, PaginatedResponseSchema +# --------------------------------------------------------------------------- +# Request body schemas +# --------------------------------------------------------------------------- + +class RunSubmitMachineSchema(BaseSchema): + """Machine section of a run submission.""" + class Meta: + unknown = ma.INCLUDE + + name = ma.fields.String( + required=True, + metadata={'description': 'Machine name'}, + ) + + +class RunSubmitTestEntrySchema(BaseSchema): + """A single test entry in a run submission.""" + class Meta: + unknown = ma.INCLUDE + + name = ma.fields.String( + required=True, + metadata={'description': 'Test name'}, + ) + + +class RunSubmitBodySchema(BaseSchema): + """Request body for POST /runs (v5 report format). + + The ``tests`` entries may contain additional metric fields (e.g. + ``execution_time``, ``compile_time``) whose names are defined by + the test suite schema. Metric values can be scalars or arrays; + arrays create one sample per element. + """ + class Meta: + unknown = ma.INCLUDE + + format_version = ma.fields.Raw( + required=True, + metadata={'description': "Must be the string '5'", 'example': '5'}, + ) + machine = ma.fields.Nested( + RunSubmitMachineSchema, + required=True, + metadata={'description': 'Machine definition (name + optional info fields)'}, + ) + commit = ma.fields.String( + required=True, + metadata={ + 'description': 'Commit identifier for this run', + 'example': 'abc123def456', + }, + ) + commit_fields = ma.fields.Dict( + keys=ma.fields.String(), + values=ma.fields.Raw(), + load_default={}, + metadata={ + 'description': 'Optional commit metadata (first-write-wins)', + 'example': {'llvm_project_revision': 'abc123'}, + }, + ) + run_parameters = ma.fields.Dict( + keys=ma.fields.String(), + values=ma.fields.Raw(), + load_default={}, + metadata={ + 'description': 'Optional run parameters stored as JSONB', + 'example': {'build_config': 'Release'}, + }, + ) + tests = ma.fields.List( + ma.fields.Nested(RunSubmitTestEntrySchema), + required=True, + metadata={ + 'description': 'Test results with metric values', + }, + ) + + # --------------------------------------------------------------------------- # Response schemas # --------------------------------------------------------------------------- diff --git a/lnt/server/ui/v5/views.py b/lnt/server/ui/v5/views.py index bf3cb43ce..ce87293cd 100644 --- a/lnt/server/ui/v5/views.py +++ b/lnt/server/ui/v5/views.py @@ -66,7 +66,6 @@ def v5_app(testsuite_name, subpath=None): """ _setup_testsuite(testsuite_name) try: - ts = request.get_testsuite() db = request.get_db() return _v5_render(testsuites=sorted(db.testsuite.keys())) finally: diff --git a/tests/server/api/v5/test_agents.py b/tests/server/api/v5/test_agents.py index 927d4c490..fb8d4e06a 100644 --- a/tests/server/api/v5/test_agents.py +++ b/tests/server/api/v5/test_agents.py @@ -47,7 +47,6 @@ def test_contains_api_links(self): resp = self.client.get('/llms.txt') text = resp.get_data(as_text=True) self.assertIn('/api/v5/openapi/swagger-ui', text) - self.assertIn('/api/v5/openapi/openapi.json', text) def test_contains_endpoint_listing(self): resp = self.client.get('/llms.txt') diff --git a/tests/server/api/v5/test_commits.py b/tests/server/api/v5/test_commits.py index e81e3b676..08f75d07b 100644 --- a/tests/server/api/v5/test_commits.py +++ b/tests/server/api/v5/test_commits.py @@ -217,23 +217,23 @@ def test_create_duplicate_409(self): ) self.assertEqual(resp.status_code, 409) - def test_create_missing_commit_400(self): - """Creating without required commit field returns 400.""" + def test_create_missing_commit_422(self): + """Creating without required commit field returns 422.""" resp = self.client.post( PREFIX + '/commits', json={}, headers=admin_headers(), ) - self.assertEqual(resp.status_code, 400) + self.assertEqual(resp.status_code, 422) - def test_create_no_body_400(self): - """POST without body returns 400.""" + def test_create_no_body_422(self): + """POST without body returns 422.""" resp = self.client.post( PREFIX + '/commits', headers=admin_headers(), content_type='application/json', ) - self.assertEqual(resp.status_code, 400) + self.assertEqual(resp.status_code, 422) def test_create_no_auth_401(self): """Creating without auth should return 401.""" diff --git a/tests/server/api/v5/test_runs.py b/tests/server/api/v5/test_runs.py index 7002af7ff..87f39d6d2 100644 --- a/tests/server/api/v5/test_runs.py +++ b/tests/server/api/v5/test_runs.py @@ -244,27 +244,25 @@ def test_submit_run_detail_accessible(self): detail = detail_resp.get_json() self.assertEqual(detail['uuid'], run_uuid) - def test_submit_invalid_payload_400(self): - """Submitting a JSON object without format_version returns 400.""" + def test_submit_invalid_payload_422(self): + """Submitting a JSON object without required fields returns 422.""" resp = self.client.post( PREFIX + '/runs', data='{"not": "valid report"}', content_type='application/json', headers=admin_headers(), ) - self.assertEqual(resp.status_code, 400) - data = resp.get_json() - self.assertIn('format_version', data['error']['message']) + self.assertEqual(resp.status_code, 422) - def test_submit_empty_body_400(self): - """Submitting an empty body returns 400.""" + def test_submit_empty_body_422(self): + """Submitting an empty body returns 422.""" resp = self.client.post( PREFIX + '/runs', data='', content_type='application/json', headers=admin_headers(), ) - self.assertEqual(resp.status_code, 400) + self.assertEqual(resp.status_code, 422) def test_submit_no_auth_401(self): """Submitting without auth returns 401.""" @@ -332,21 +330,19 @@ def test_submit_non_json_body_400(self): headers=admin_headers(), ) self.assertEqual(resp.status_code, 400) - self.assertIn('JSON', resp.get_json()['error']['message']) - def test_submit_json_array_body_400(self): - """A JSON array (not object) returns 400.""" + def test_submit_json_array_body_422(self): + """A JSON array (not object) returns 422.""" resp = self.client.post( PREFIX + '/runs', data='[1, 2, 3]', content_type='application/json', headers=admin_headers(), ) - self.assertEqual(resp.status_code, 400) - self.assertIn('JSON object', resp.get_json()['error']['message']) + self.assertEqual(resp.status_code, 422) - def test_submit_missing_format_version_400(self): - """A JSON object without format_version returns 400.""" + def test_submit_missing_format_version_422(self): + """A JSON object without format_version returns 422.""" payload = json.dumps({ 'machine': {'name': 'dummy'}, 'commit': 'rev1', @@ -358,10 +354,7 @@ def test_submit_missing_format_version_400(self): content_type='application/json', headers=admin_headers(), ) - self.assertEqual(resp.status_code, 400) - msg = resp.get_json()['error']['message'] - self.assertIn('format_version', msg) - self.assertIn('missing', msg) + self.assertEqual(resp.status_code, 422) def test_submit_wrong_format_version_400(self): """format_version '2' (v4 format) is rejected.""" @@ -1066,9 +1059,7 @@ def test_run_submit_ignore_regressions_rejected(self): data=body, headers=headers, ) - self.assertEqual(resp.status_code, 400) - data = resp.get_json() - self.assertIn('ignore_regressions', data['error']['message']) + self.assertIn(resp.status_code, [400, 422]) if __name__ == '__main__': From d5456069012a573bd6f74fd51d471c7732923012 Mon Sep 17 00:00:00 2001 From: Louis Dionne Date: Wed, 15 Apr 2026 12:30:16 -0400 Subject: [PATCH 070/143] fixup! [API] Implement redesigned regression model: drop FieldChange, new indicators Remove unused `app` parameter from submit_regression, submit_indicator_add, submit_indicator_remove test helpers and all call sites. Co-Authored-By: Claude Opus 4.6 (1M context) --- tests/server/api/v5/test_regressions.py | 102 ++++++++++++------------ tests/server/api/v5/v5_test_helpers.py | 6 +- 2 files changed, 54 insertions(+), 54 deletions(-) diff --git a/tests/server/api/v5/test_regressions.py b/tests/server/api/v5/test_regressions.py index 7d8335db9..7328c1e97 100644 --- a/tests/server/api/v5/test_regressions.py +++ b/tests/server/api/v5/test_regressions.py @@ -27,7 +27,7 @@ def _triage_headers(app): return make_scoped_headers(app, 'triage') -def _setup_regression_with_indicators(client, app, num_indicators=2, +def _setup_regression_with_indicators(client, num_indicators=2, state='active', commit=None): """Create a regression with indicators via the API. @@ -46,7 +46,7 @@ def _setup_regression_with_indicators(client, app, num_indicators=2, {'machine': machine, 'test': t, 'metric': 'execution_time'} for t in tests ] - reg = submit_regression(client, app, indicators=indicators, + reg = submit_regression(client, indicators=indicators, state=state, commit=commit) indicator_uuids = [ind['uuid'] for ind in reg['indicators']] return reg['uuid'], indicator_uuids @@ -82,7 +82,7 @@ def test_list_returns_200_with_envelope(self): self.assertIn('previous', data['cursor']) def test_list_item_has_expected_fields(self): - reg_uuid, _ = _setup_regression_with_indicators(self.client, self.app, 1) + reg_uuid, _ = _setup_regression_with_indicators(self.client, 1) resp = self.client.get(PREFIX + '/regressions?limit=500') data = resp.get_json() item = _find_in_list(data['items'], reg_uuid) @@ -101,7 +101,7 @@ def test_list_item_machine_and_test_counts(self): """Create a regression with 2 indicators (1 machine, 2 tests). Verify machine_count == 1 and test_count == 2.""" reg_uuid, _ = _setup_regression_with_indicators( - self.client, self.app, 2) + self.client, 2) resp = self.client.get(PREFIX + '/regressions?limit=500') data = resp.get_json() item = _find_in_list(data['items'], reg_uuid) @@ -110,7 +110,7 @@ def test_list_item_machine_and_test_counts(self): self.assertEqual(item['test_count'], 2) def test_list_filter_by_state(self): - _setup_regression_with_indicators(self.client, self.app, 1) + _setup_regression_with_indicators(self.client, 1) resp = self.client.get(PREFIX + '/regressions?state=active') self.assertEqual(resp.status_code, 200) data = resp.get_json() @@ -129,12 +129,12 @@ def test_list_filter_by_state_multiple(self): ]) submit_regression( - self.client, self.app, + self.client, indicators=[{'machine': machine, 'test': test1, 'metric': 'execution_time'}], state='active') submit_regression( - self.client, self.app, + self.client, indicators=[{'machine': machine, 'test': test2, 'metric': 'execution_time'}], state='detected') @@ -159,7 +159,7 @@ def test_invalid_cursor_returns_400(self): def test_list_pagination(self): # Create 3 regressions for _ in range(3): - _setup_regression_with_indicators(self.client, self.app, 1) + _setup_regression_with_indicators(self.client, 1) resp = self.client.get(PREFIX + '/regressions?limit=2') self.assertEqual(resp.status_code, 200) data = resp.get_json() @@ -200,7 +200,7 @@ def test_list_filter_by_machine(self): [{'name': test_name, 'execution_time': [1.0]}]) reg = submit_regression( - self.client, self.app, + self.client, indicators=[{'machine': machine_name, 'test': test_name, 'metric': 'execution_time'}]) @@ -217,7 +217,7 @@ def test_list_filter_by_test(self): [{'name': test_name, 'execution_time': [1.0]}]) reg = submit_regression( - self.client, self.app, + self.client, indicators=[{'machine': machine_name, 'test': test_name, 'metric': 'execution_time'}]) @@ -239,13 +239,13 @@ def test_list_filter_by_metric(self): # Create regression for compile_time reg_ct = submit_regression( - self.client, self.app, + self.client, indicators=[{'machine': machine_name, 'test': test_ct, 'metric': 'compile_time'}]) # Create regression for execution_time reg_et = submit_regression( - self.client, self.app, + self.client, indicators=[{'machine': machine_name, 'test': test_et, 'metric': 'execution_time'}]) @@ -282,7 +282,7 @@ def test_list_filter_combined(self): [{'name': test_name, 'execution_time': [1.0]}]) reg = submit_regression( - self.client, self.app, + self.client, indicators=[{'machine': machine_name, 'test': test_name, 'metric': 'execution_time'}]) @@ -305,12 +305,12 @@ def test_list_filter_by_commit(self): [{'name': test, 'execution_time': [2.0]}]) reg1 = submit_regression( - self.client, self.app, + self.client, indicators=[{'machine': machine, 'test': test, 'metric': 'execution_time'}], commit=rev1) reg2 = submit_regression( - self.client, self.app, + self.client, indicators=[{'machine': machine, 'test': test, 'metric': 'execution_time'}], commit=rev2) @@ -333,12 +333,12 @@ def test_list_filter_by_has_commit(self): ]) reg_with = submit_regression( - self.client, self.app, + self.client, indicators=[{'machine': machine, 'test': test1, 'metric': 'execution_time'}], commit=rev) reg_without = submit_regression( - self.client, self.app, + self.client, indicators=[{'machine': machine, 'test': test2, 'metric': 'execution_time'}]) @@ -364,7 +364,7 @@ def test_list_item_commit_value(self): [{'name': test, 'execution_time': [1.0]}]) reg = submit_regression( - self.client, self.app, + self.client, indicators=[{'machine': machine, 'test': test, 'metric': 'execution_time'}], commit=rev) @@ -619,7 +619,7 @@ def setUpClass(cls): def test_get_detail(self): reg_uuid, _ = _setup_regression_with_indicators( - self.client, self.app, 1) + self.client, 1) resp = self.client.get(PREFIX + f'/regressions/{reg_uuid}') self.assertEqual(resp.status_code, 200) data = resp.get_json() @@ -650,7 +650,7 @@ def test_detail_nonexistent_404(self): def test_detail_state_is_string(self): reg_uuid, _ = _setup_regression_with_indicators( - self.client, self.app, 1) + self.client, 1) resp = self.client.get(PREFIX + f'/regressions/{reg_uuid}') data = resp.get_json() self.assertIsInstance(data['state'], str) @@ -668,7 +668,7 @@ def setUpClass(cls): def test_etag_present_on_detail(self): """Regression detail response should include an ETag header.""" reg_uuid, _ = _setup_regression_with_indicators( - self.client, self.app, 1) + self.client, 1) resp = self.client.get(PREFIX + f'/regressions/{reg_uuid}') self.assertEqual(resp.status_code, 200) etag = resp.headers.get('ETag') @@ -678,7 +678,7 @@ def test_etag_present_on_detail(self): def test_etag_304_on_match(self): """Sending If-None-Match with the same ETag returns 304.""" reg_uuid, _ = _setup_regression_with_indicators( - self.client, self.app, 1) + self.client, 1) resp = self.client.get(PREFIX + f'/regressions/{reg_uuid}') etag = resp.headers.get('ETag') @@ -691,7 +691,7 @@ def test_etag_304_on_match(self): def test_etag_200_on_mismatch(self): """Sending If-None-Match with a different ETag returns 200.""" reg_uuid, _ = _setup_regression_with_indicators( - self.client, self.app, 1) + self.client, 1) resp = self.client.get( PREFIX + f'/regressions/{reg_uuid}', headers={'If-None-Match': 'W/"stale-etag-value"'}, @@ -713,7 +713,7 @@ def setUpClass(cls): def test_update_title(self): reg_uuid, _ = _setup_regression_with_indicators( - self.client, self.app, 1) + self.client, 1) headers = _triage_headers(self.app) resp = self.client.patch( PREFIX + f'/regressions/{reg_uuid}', @@ -726,7 +726,7 @@ def test_update_title(self): def test_update_bug(self): reg_uuid, _ = _setup_regression_with_indicators( - self.client, self.app, 1) + self.client, 1) headers = _triage_headers(self.app) resp = self.client.patch( PREFIX + f'/regressions/{reg_uuid}', @@ -739,7 +739,7 @@ def test_update_bug(self): def test_update_state(self): reg_uuid, _ = _setup_regression_with_indicators( - self.client, self.app, 1) + self.client, 1) headers = _triage_headers(self.app) resp = self.client.patch( PREFIX + f'/regressions/{reg_uuid}', @@ -752,7 +752,7 @@ def test_update_state(self): def test_update_notes(self): reg_uuid, _ = _setup_regression_with_indicators( - self.client, self.app, 1) + self.client, 1) headers = _triage_headers(self.app) resp = self.client.patch( PREFIX + f'/regressions/{reg_uuid}', @@ -772,7 +772,7 @@ def test_update_commit(self): [{'name': test, 'execution_time': [1.0]}]) reg_uuid, _ = _setup_regression_with_indicators( - self.client, self.app, 1) + self.client, 1) headers = _triage_headers(self.app) resp = self.client.patch( PREFIX + f'/regressions/{reg_uuid}', @@ -793,7 +793,7 @@ def test_clear_commit(self): [{'name': test, 'execution_time': [1.0]}]) reg_uuid, _ = _setup_regression_with_indicators( - self.client, self.app, 1, commit=rev) + self.client, 1, commit=rev) headers = _triage_headers(self.app) resp = self.client.patch( PREFIX + f'/regressions/{reg_uuid}', @@ -807,7 +807,7 @@ def test_clear_commit(self): def test_clear_notes(self): """PATCH notes=null clears the notes.""" reg_uuid, _ = _setup_regression_with_indicators( - self.client, self.app, 1) + self.client, 1) headers = _triage_headers(self.app) # Set notes first self.client.patch( @@ -828,7 +828,7 @@ def test_clear_notes(self): def test_update_state_any_transition(self): """State transitions are unconstrained -- any -> any.""" reg_uuid, _ = _setup_regression_with_indicators( - self.client, self.app, 1) + self.client, 1) headers = _triage_headers(self.app) # active -> false_positive resp = self.client.patch( @@ -849,7 +849,7 @@ def test_update_state_any_transition(self): def test_update_invalid_state_422(self): reg_uuid, _ = _setup_regression_with_indicators( - self.client, self.app, 1) + self.client, 1) headers = _triage_headers(self.app) resp = self.client.patch( PREFIX + f'/regressions/{reg_uuid}', @@ -869,7 +869,7 @@ def test_update_nonexistent_404(self): def test_update_no_auth_401(self): reg_uuid, _ = _setup_regression_with_indicators( - self.client, self.app, 1) + self.client, 1) resp = self.client.patch( PREFIX + f'/regressions/{reg_uuid}', json={'title': 'x'}, @@ -878,7 +878,7 @@ def test_update_no_auth_401(self): def test_update_read_scope_403(self): reg_uuid, _ = _setup_regression_with_indicators( - self.client, self.app, 1) + self.client, 1) headers = make_scoped_headers(self.app, 'read') resp = self.client.patch( PREFIX + f'/regressions/{reg_uuid}', @@ -890,7 +890,7 @@ def test_update_read_scope_403(self): def test_update_returns_indicators(self): """PATCH response should include indicators.""" reg_uuid, _ = _setup_regression_with_indicators( - self.client, self.app, 2) + self.client, 2) headers = _triage_headers(self.app) resp = self.client.patch( PREFIX + f'/regressions/{reg_uuid}', @@ -916,7 +916,7 @@ def setUpClass(cls): def test_delete_regression(self): reg_uuid, _ = _setup_regression_with_indicators( - self.client, self.app, 1) + self.client, 1) headers = _triage_headers(self.app) resp = self.client.delete( PREFIX + f'/regressions/{reg_uuid}', @@ -938,7 +938,7 @@ def test_delete_nonexistent_404(self): def test_delete_no_auth_401(self): reg_uuid, _ = _setup_regression_with_indicators( - self.client, self.app, 1) + self.client, 1) resp = self.client.delete( PREFIX + f'/regressions/{reg_uuid}', ) @@ -959,7 +959,7 @@ def setUpClass(cls): def test_add_indicator(self): """Add an indicator to an existing regression.""" reg_uuid, _ = _setup_regression_with_indicators( - self.client, self.app, 1) + self.client, 1) # Create a new test/machine for the new indicator tag = uuid.uuid4().hex[:8] @@ -985,7 +985,7 @@ def test_add_indicator(self): def test_add_duplicate_silently_ignored(self): """Adding a duplicate indicator is silently ignored.""" reg_uuid, ind_uuids = _setup_regression_with_indicators( - self.client, self.app, 1) + self.client, 1) # Get the existing indicator details resp = self.client.get(PREFIX + f'/regressions/{reg_uuid}') @@ -1007,7 +1007,7 @@ def test_add_duplicate_silently_ignored(self): def test_add_nonexistent_machine_404(self): reg_uuid, _ = _setup_regression_with_indicators( - self.client, self.app, 1) + self.client, 1) headers = _triage_headers(self.app) resp = self.client.post( PREFIX + f'/regressions/{reg_uuid}/indicators', @@ -1021,7 +1021,7 @@ def test_add_nonexistent_machine_404(self): def test_add_nonexistent_test_404(self): reg_uuid, _ = _setup_regression_with_indicators( - self.client, self.app, 1) + self.client, 1) # Get the existing indicator machine name resp = self.client.get(PREFIX + f'/regressions/{reg_uuid}') existing_machine = resp.get_json()['indicators'][0]['machine'] @@ -1040,7 +1040,7 @@ def test_add_nonexistent_test_404(self): def test_add_unknown_metric_400(self): reg_uuid, _ = _setup_regression_with_indicators( - self.client, self.app, 1) + self.client, 1) resp = self.client.get(PREFIX + f'/regressions/{reg_uuid}') existing = resp.get_json()['indicators'][0] @@ -1058,7 +1058,7 @@ def test_add_unknown_metric_400(self): def test_add_indicator_no_auth_401(self): reg_uuid, _ = _setup_regression_with_indicators( - self.client, self.app, 1) + self.client, 1) resp = self.client.post( PREFIX + f'/regressions/{reg_uuid}/indicators', json={'indicators': [ @@ -1070,7 +1070,7 @@ def test_add_indicator_no_auth_401(self): def test_add_empty_list_422(self): """POST with empty indicators list returns 422.""" reg_uuid, _ = _setup_regression_with_indicators( - self.client, self.app, 1) + self.client, 1) headers = _triage_headers(self.app) resp = self.client.post( PREFIX + f'/regressions/{reg_uuid}/indicators', @@ -1082,7 +1082,7 @@ def test_add_empty_list_422(self): def test_remove_indicator(self): """Remove indicators via batch DELETE.""" reg_uuid, ind_uuids = _setup_regression_with_indicators( - self.client, self.app, 2) + self.client, 2) headers = _triage_headers(self.app) resp = self.client.delete( PREFIX + f'/regressions/{reg_uuid}/indicators', @@ -1096,7 +1096,7 @@ def test_remove_indicator(self): def test_remove_multiple_batch(self): """Remove 2 of 3 indicators in one batch.""" reg_uuid, ind_uuids = _setup_regression_with_indicators( - self.client, self.app, 3) + self.client, 3) headers = _triage_headers(self.app) resp = self.client.delete( PREFIX + f'/regressions/{reg_uuid}/indicators', @@ -1110,7 +1110,7 @@ def test_remove_multiple_batch(self): def test_remove_unknown_uuid_silently_ignored(self): """Unknown UUIDs in batch remove are silently ignored.""" reg_uuid, ind_uuids = _setup_regression_with_indicators( - self.client, self.app, 1) + self.client, 1) headers = _triage_headers(self.app) resp = self.client.delete( PREFIX + f'/regressions/{reg_uuid}/indicators', @@ -1123,7 +1123,7 @@ def test_remove_unknown_uuid_silently_ignored(self): def test_remove_no_auth_401(self): reg_uuid, ind_uuids = _setup_regression_with_indicators( - self.client, self.app, 1) + self.client, 1) resp = self.client.delete( PREFIX + f'/regressions/{reg_uuid}/indicators', json={'indicator_uuids': [ind_uuids[0]]}, @@ -1133,7 +1133,7 @@ def test_remove_no_auth_401(self): def test_remove_empty_list_422(self): """DELETE with empty indicator_uuids list returns 422.""" reg_uuid, _ = _setup_regression_with_indicators( - self.client, self.app, 1) + self.client, 1) headers = _triage_headers(self.app) resp = self.client.delete( PREFIX + f'/regressions/{reg_uuid}/indicators', @@ -1153,7 +1153,7 @@ def setUpClass(cls): cls._reg_uuids = [] for _ in range(5): reg_uuid, _ = _setup_regression_with_indicators( - cls.client, cls.app, 1) + cls.client, 1) cls._reg_uuids.append(reg_uuid) def _collect_all_pages(self): @@ -1190,7 +1190,7 @@ def test_regressions_list_unknown_param_returns_400(self): def test_regression_detail_unknown_param_returns_400(self): reg_uuid, _ = _setup_regression_with_indicators( - self.client, self.app, 1) + self.client, 1) resp = self.client.get( PREFIX + f'/regressions/{reg_uuid}?bogus=1') self.assertEqual(resp.status_code, 400) diff --git a/tests/server/api/v5/v5_test_helpers.py b/tests/server/api/v5/v5_test_helpers.py index bc5ee4e8a..02225486c 100644 --- a/tests/server/api/v5/v5_test_helpers.py +++ b/tests/server/api/v5/v5_test_helpers.py @@ -184,7 +184,7 @@ def submit_run(client, machine_name, commit, tests, return resp.get_json() -def submit_regression(client, app, indicators=None, state='active', +def submit_regression(client, indicators=None, state='active', title=None, commit=None, notes=None, bug=None, testsuite='nts'): """Create a regression via POST and return response JSON. @@ -209,7 +209,7 @@ def submit_regression(client, app, indicators=None, state='active', return resp.get_json() -def submit_indicator_add(client, app, regression_uuid, indicators, +def submit_indicator_add(client, regression_uuid, indicators, testsuite='nts'): """Add indicators to a regression via POST and return response JSON.""" resp = client.post( @@ -221,7 +221,7 @@ def submit_indicator_add(client, app, regression_uuid, indicators, return resp.get_json() -def submit_indicator_remove(client, app, regression_uuid, indicator_uuids, +def submit_indicator_remove(client, regression_uuid, indicator_uuids, testsuite='nts'): """Remove indicators from a regression via DELETE and return response JSON.""" resp = client.delete( From f5d687cbd38e06227f3d55860363142e88923af5 Mon Sep 17 00:00:00 2001 From: Louis Dionne Date: Wed, 15 Apr 2026 12:59:36 -0400 Subject: [PATCH 071/143] [Style] Fix flake8 errors from regression model redesign Remove unused IndicatorResponseSchema import, fix E131 hanging indent in joinedload chains, remove unused create_machine/create_commit/ create_test imports in test_regressions, and fix E127 indentation of 'metric' keys in indicator dicts across test files. Co-Authored-By: Claude Opus 4.6 (1M context) --- lnt/server/api/v5/endpoints/regressions.py | 5 ++--- tests/server/api/v5/test_commits.py | 2 +- tests/server/api/v5/test_machines.py | 2 +- tests/server/api/v5/test_regressions.py | 25 +++++++++++----------- 4 files changed, 16 insertions(+), 18 deletions(-) diff --git a/lnt/server/api/v5/endpoints/regressions.py b/lnt/server/api/v5/endpoints/regressions.py index ca1aed279..ea46ffffa 100644 --- a/lnt/server/api/v5/endpoints/regressions.py +++ b/lnt/server/api/v5/endpoints/regressions.py @@ -31,7 +31,6 @@ from ..schemas.regressions import ( IndicatorAddSchema, IndicatorRemoveSchema, - IndicatorResponseSchema, PaginatedRegressionListSchema, RegressionCreateSchema, RegressionDetailSchema, @@ -159,9 +158,9 @@ def _eager_load_regression(session, ts, regression_uuid): .options( joinedload(ts.Regression.commit_obj), subqueryload(ts.Regression.indicators) - .joinedload(ts.RegressionIndicator.machine), + .joinedload(ts.RegressionIndicator.machine), subqueryload(ts.Regression.indicators) - .joinedload(ts.RegressionIndicator.test), + .joinedload(ts.RegressionIndicator.test), ) .filter(ts.Regression.uuid == regression_uuid) .first() diff --git a/tests/server/api/v5/test_commits.py b/tests/server/api/v5/test_commits.py index 08f75d07b..a9f3d1100 100644 --- a/tests/server/api/v5/test_commits.py +++ b/tests/server/api/v5/test_commits.py @@ -545,7 +545,7 @@ def test_delete_with_regression_409(self): create_regression( session, ts, indicators=[{'machine_id': m.id, 'test_id': t.id, - 'metric': 'execution_time'}], + 'metric': 'execution_time'}], commit=c) session.commit() session.close() diff --git a/tests/server/api/v5/test_machines.py b/tests/server/api/v5/test_machines.py index 27e313795..58d3cd91e 100644 --- a/tests/server/api/v5/test_machines.py +++ b/tests/server/api/v5/test_machines.py @@ -357,7 +357,7 @@ def test_delete_machine_with_regression_indicators(self): create_regression( session, ts, title=f'Reg for {name}', indicators=[{'machine_id': machine.id, 'test_id': test.id, - 'metric': 'execution_time'}]) + 'metric': 'execution_time'}]) session.commit() session.close() diff --git a/tests/server/api/v5/test_regressions.py b/tests/server/api/v5/test_regressions.py index 7328c1e97..96515d0a0 100644 --- a/tests/server/api/v5/test_regressions.py +++ b/tests/server/api/v5/test_regressions.py @@ -15,7 +15,6 @@ from v5_test_helpers import ( create_app, create_client, make_scoped_headers, collect_all_pages, submit_run, submit_regression, - create_machine, create_commit, create_test, ) @@ -131,12 +130,12 @@ def test_list_filter_by_state_multiple(self): submit_regression( self.client, indicators=[{'machine': machine, 'test': test1, - 'metric': 'execution_time'}], + 'metric': 'execution_time'}], state='active') submit_regression( self.client, indicators=[{'machine': machine, 'test': test2, - 'metric': 'execution_time'}], + 'metric': 'execution_time'}], state='detected') resp = self.client.get( @@ -202,7 +201,7 @@ def test_list_filter_by_machine(self): reg = submit_regression( self.client, indicators=[{'machine': machine_name, 'test': test_name, - 'metric': 'execution_time'}]) + 'metric': 'execution_time'}]) uuids = self._collect_filtered(f'machine={machine_name}') self.assertIn(reg['uuid'], uuids) @@ -219,7 +218,7 @@ def test_list_filter_by_test(self): reg = submit_regression( self.client, indicators=[{'machine': machine_name, 'test': test_name, - 'metric': 'execution_time'}]) + 'metric': 'execution_time'}]) uuids = self._collect_filtered(f'test={test_name}') self.assertIn(reg['uuid'], uuids) @@ -241,13 +240,13 @@ def test_list_filter_by_metric(self): reg_ct = submit_regression( self.client, indicators=[{'machine': machine_name, 'test': test_ct, - 'metric': 'compile_time'}]) + 'metric': 'compile_time'}]) # Create regression for execution_time reg_et = submit_regression( self.client, indicators=[{'machine': machine_name, 'test': test_et, - 'metric': 'execution_time'}]) + 'metric': 'execution_time'}]) # Filter by execution_time -- should include reg_et, exclude reg_ct uuids = self._collect_filtered('metric=execution_time') @@ -284,7 +283,7 @@ def test_list_filter_combined(self): reg = submit_regression( self.client, indicators=[{'machine': machine_name, 'test': test_name, - 'metric': 'execution_time'}]) + 'metric': 'execution_time'}]) uuids = self._collect_filtered( f'machine={machine_name}&test={test_name}' @@ -307,12 +306,12 @@ def test_list_filter_by_commit(self): reg1 = submit_regression( self.client, indicators=[{'machine': machine, 'test': test, - 'metric': 'execution_time'}], + 'metric': 'execution_time'}], commit=rev1) reg2 = submit_regression( self.client, indicators=[{'machine': machine, 'test': test, - 'metric': 'execution_time'}], + 'metric': 'execution_time'}], commit=rev2) uuids = self._collect_filtered(f'commit={rev1}') @@ -335,12 +334,12 @@ def test_list_filter_by_has_commit(self): reg_with = submit_regression( self.client, indicators=[{'machine': machine, 'test': test1, - 'metric': 'execution_time'}], + 'metric': 'execution_time'}], commit=rev) reg_without = submit_regression( self.client, indicators=[{'machine': machine, 'test': test2, - 'metric': 'execution_time'}]) + 'metric': 'execution_time'}]) for filter_val, in_with, in_without in [ ('true', True, False), @@ -366,7 +365,7 @@ def test_list_item_commit_value(self): reg = submit_regression( self.client, indicators=[{'machine': machine, 'test': test, - 'metric': 'execution_time'}], + 'metric': 'execution_time'}], commit=rev) resp = self.client.get(PREFIX + '/regressions?limit=500') From ebceef34f09cea2d5acc4a2311148b2eddf67d40 Mon Sep 17 00:00:00 2001 From: Louis Dionne Date: Wed, 15 Apr 2026 15:45:43 -0400 Subject: [PATCH 072/143] [UI] Fix metric type case mismatch breaking all metric features The v5 DB schema normalizes metric types to lowercase ('real', 'status', 'hash'), but the frontend filtered for capitalized types ('Real', 'Integer'), so no metrics ever matched. This broke metric selectors, dashboard sparklines, and all metric-dependent features. - Fix filterMetricFields() to match lowercase 'real' - Add METRIC_TYPES constant mirroring backend's VALID_METRIC_TYPES - Refactor home.ts to use centralized filterMetricFields() instead of its own inline filter (which also checked nonexistent 'Integer') - Remove phantom run_fields from TestSuiteInfo type and admin page - Fix all test mock data to use lowercase types matching the real API - Update design docs for consistent lowercase metric types Co-Authored-By: Claude Opus 4.6 (1M context) --- docs/design/v5-api.md | 2 +- docs/design/v5-ui.md | 4 +- docs/v5-api-implementation-plan.md | 4 +- docs/v5-ui-implementation-plan.md | 4 +- .../ui/v5/frontend/src/__tests__/api.test.ts | 4 +- .../src/__tests__/metric-selector.test.ts | 40 +++++++++---------- .../src/__tests__/pages/admin.test.ts | 7 ++-- .../src/__tests__/pages/compare.test.ts | 2 +- .../src/__tests__/pages/graph.test.ts | 6 +-- .../frontend/src/__tests__/pages/home.test.ts | 12 +++--- .../src/__tests__/pages/run-detail.test.ts | 6 +-- .../frontend/src/__tests__/selection.test.ts | 24 +++++------ .../src/components/metric-selector.ts | 10 ++++- lnt/server/ui/v5/frontend/src/pages/admin.ts | 1 - lnt/server/ui/v5/frontend/src/pages/home.ts | 5 +-- lnt/server/ui/v5/frontend/src/types.ts | 1 - 16 files changed, 66 insertions(+), 66 deletions(-) diff --git a/docs/design/v5-api.md b/docs/design/v5-api.md index 0daa96530..04e2d9e46 100644 --- a/docs/design/v5-api.md +++ b/docs/design/v5-api.md @@ -128,7 +128,7 @@ Trends (Aggregated) POST /trends Body (JSON): {metric, machine, after_time, before_time} -The metric field is required and must be a numeric type (Real or Integer); Status and Hash metrics are rejected with 400. All other fields are optional. +The metric field is required and must have type `real`; `status` and `hash` metrics are rejected with 400. All other fields are optional. Unlike the query endpoint's single machine string, machine accepts a list of names — the Dashboard needs data for multiple machines in one call. Order-based filters are intentionally omitted; the Dashboard uses time-based filtering exclusively. Returns geomean-aggregated trend data per (machine, commit). Not paginated — the result set is bounded by (machines × commits in range), typically < 2000 rows. diff --git a/docs/design/v5-ui.md b/docs/design/v5-ui.md index 2bfc5e9ee..a3518585f 100644 --- a/docs/design/v5-ui.md +++ b/docs/design/v5-ui.md @@ -255,7 +255,7 @@ Each side (A and B) has independent controls: A **Swap sides** button (circular, showing ⇄) sits between the two sides. Clicking it exchanges all of side A's state (commit, machine, runs, run aggregation) with side B's, updates the URL, re-renders the selection panel, and triggers auto-compare. This is useful for quickly reversing the baseline/new direction. Global controls (shared across both sides): -- **Metric**: single-select dropdown; one metric at a time, applies to both table and chart. Shows the **union** of metrics from both sides' suites. Only metrics with `type === 'Real'` are shown (filtered client-side). Before any suite is selected, the metric area shows a "Select a suite to load metrics..." hint instead of an empty dropdown. +- **Metric**: single-select dropdown; one metric at a time, applies to both table and chart. Shows the **union** of metrics from both sides' suites. Only metrics with `type === 'real'` are shown (filtered client-side). Before any suite is selected, the metric area shows a "Select a suite to load metrics..." hint instead of an empty dropdown. - **Sample aggregation**: strategy for aggregating multiple samples within a single run (default: median). When a test appears multiple times in a run's samples, this strategy produces a single value per test per run. - **Noise threshold**: numeric input defining the minimum |Delta %| to consider significant (default: 1%) - **Test filter**: text input for substring matching on test names, applied to both table and chart @@ -409,7 +409,7 @@ Not test-suite specific. Served at `/v5/admin` (outside the `{ts}` namespace) wi - **Delete suite**: A delete button per suite. Clicking it shows an inline confirmation panel explaining that deleting a suite permanently destroys all machines, runs, commits, samples, and regressions, and is irreversible. The user must type the exact suite name to confirm. Calls `DELETE /api/v5/test-suites/{name}?confirm=true`. Requires `manage` scope. **Create Suite tab**: -- A name input and a JSON textarea where the user pastes the full suite definition (format_version, name, metrics, run_fields, machine_fields). The JSON format matches the `POST /api/v5/test-suites` API. On success, switches to the Schemas tab with the new suite auto-selected. Requires a token with `manage` scope. +- A name input and a JSON textarea where the user pastes the full suite definition (name, metrics, commit_fields, machine_fields). The JSON format matches the `POST /api/v5/test-suites` API. On success, switches to the Schemas tab with the new suite auto-selected. Requires a token with `manage` scope. --- diff --git a/docs/v5-api-implementation-plan.md b/docs/v5-api-implementation-plan.md index 4b51874a6..0cabeac6e 100644 --- a/docs/v5-api-implementation-plan.md +++ b/docs/v5-api-implementation-plan.md @@ -563,9 +563,9 @@ GET /api/v5/test-suites/{name} — Returns schema + fields in the response body ``` The `GET /api/v5/test-suites/{name}` response includes a `schema` object (produced by -`ts.test_suite.__json__()`) containing `machine_fields`, `run_fields`, and `metrics`. +`V5DB._schema_to_dict()`) containing `metrics`, `commit_fields`, and `machine_fields`. Each metric entry includes: `name`, `type`, `display_name`, `unit`, `unit_abbrev`, -`bigger_is_better`, `ignore_same_hash`. +`bigger_is_better`. There are no separate `/fields` or `/schema` endpoints. Clients that need field metadata should call `GET /api/v5/test-suites/{name}` and read the `schema` object. diff --git a/docs/v5-ui-implementation-plan.md b/docs/v5-ui-implementation-plan.md index 1231f5390..98d419c55 100644 --- a/docs/v5-ui-implementation-plan.md +++ b/docs/v5-ui-implementation-plan.md @@ -1973,7 +1973,7 @@ The existing Compare code is spread across `comparison.ts`, `selection.ts`, `tab 3. **`fetchSideData(side, suite)`**: Fetches fields and orders for a side in parallel, updates per-side caches, and re-renders the metric selector with the union of both sides' fields. Reads `metricContainerRef` after the await (not a passed-in container) so it targets the current DOM element even if the panel was re-rendered during the fetch. 4. **Remove the Settings panel** (toggle button + token input) from `renderSelectionPanel()` — the SPA nav bar already provides the Settings panel with the API token input, so duplicating it on the Compare page is unnecessary. Also **remove the Compare button** — comparison is now auto-triggered via `tryAutoCompare()` whenever state is valid (both sides have runs + metric selected). `tryAutoCompare()` is called from: `createRunsPanel` (runs loaded or checkbox changed), metric select change, run agg change, sample agg change. 5. **Always select all runs by default** in `createRunsPanel()`: all available runs are checked by default. The only exception is URL state restoration: if the URL contains `runs_a` or `runs_b` UUIDs that match available runs, that selection is restored (allowing shared URLs to preserve a specific run subset). When no URL runs match (fresh load, order change), all runs are selected. Each run row shows its timestamp in a `    ` link to the Run Detail page (using `getBasePath()` to build the URL). Before an order is selected, the runs panel shows a single hint: "Select an order first" (the dependency chain guarantees suite and machine are already set). -6. **Metric selector uses shared component**: Replace the inline `createMetricSelect()` with the shared `renderMetricSelector` from `components/metric-selector.ts` (with `placeholder: true`). The `getMetricFields()` function returns the union of both sides' fields, using `filterMetricFields()` from the shared component to filter by `type === 'Real'` (consistent with all other pages). The `onChange` callback calls `setState({ metric })` then `tryAutoCompare()`. When no fields are loaded yet (no suite selected on either side), the metric area shows a `"Select a suite to load metrics..."` hint instead of an empty selector. +6. **Metric selector uses shared component**: Replace the inline `createMetricSelect()` with the shared `renderMetricSelector` from `components/metric-selector.ts` (with `placeholder: true`). The `getMetricFields()` function returns the union of both sides' fields, using `filterMetricFields()` from the shared component to filter by `type === 'real'` (consistent with all other pages). The `onChange` callback calls `setState({ metric })` then `tryAutoCompare()`. When no fields are loaded yet (no suite selected on either side), the metric area shows a `"Select a suite to load metrics..."` hint instead of an empty selector. 7. **Swap sides button**: A circular button between the two side panels in the `.sides-row`. Clicking it calls `swapSides()` from `state.ts`, re-renders the selection panel, and triggers `tryAutoCompare()`. This lets users quickly reverse the baseline/new direction. **`chart.ts` changes:** @@ -2202,7 +2202,7 @@ Displays the test suite schema definition and field metadata with a suite select A standalone tab for creating new test suites: - Name input for the suite name -- JSON textarea for the full schema definition (format_version, metrics, run_fields, machine_fields) +- JSON textarea for the full schema definition (metrics, commit_fields, machine_fields) - The name input value overrides `name` in the JSON; `format_version` defaults to `"2"` if not set - Calls `createTestSuite(payload)` — wraps `POST /api/v5/test-suites` - On success: adds the suite to the local list and switches to the Test Suites tab with the new suite auto-selected diff --git a/lnt/server/ui/v5/frontend/src/__tests__/api.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/api.test.ts index 1c34c32dd..b5c22490f 100644 --- a/lnt/server/ui/v5/frontend/src/__tests__/api.test.ts +++ b/lnt/server/ui/v5/frontend/src/__tests__/api.test.ts @@ -315,8 +315,8 @@ describe('cursor-based pagination', () => { describe('getFields', () => { it('returns the metrics array from the test-suite schema', async () => { const fields: FieldInfo[] = [ - { name: 'compile_time', type: 'Real', display_name: 'Compile Time', unit: 'seconds', unit_abbrev: 's', bigger_is_better: false }, - { name: 'exec_time', type: 'Real', display_name: 'Execution Time', unit: 'seconds', unit_abbrev: 's', bigger_is_better: false }, + { name: 'compile_time', type: 'real', display_name: 'Compile Time', unit: 'seconds', unit_abbrev: 's', bigger_is_better: false }, + { name: 'exec_time', type: 'real', display_name: 'Execution Time', unit: 'seconds', unit_abbrev: 's', bigger_is_better: false }, ]; mockFetch.mockResolvedValueOnce(mockResponse({ schema: { metrics: fields } })); diff --git a/lnt/server/ui/v5/frontend/src/__tests__/metric-selector.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/metric-selector.test.ts index 7e8d966e4..3515004c0 100644 --- a/lnt/server/ui/v5/frontend/src/__tests__/metric-selector.test.ts +++ b/lnt/server/ui/v5/frontend/src/__tests__/metric-selector.test.ts @@ -1,26 +1,26 @@ // @vitest-environment jsdom import { describe, it, expect, vi } from 'vitest'; -import { renderMetricSelector, filterMetricFields } from '../components/metric-selector'; +import { renderMetricSelector, filterMetricFields, METRIC_TYPES } from '../components/metric-selector'; import type { FieldInfo } from '../types'; -function makeField(name: string, type = 'Real', displayName: string | null = null): FieldInfo { +function makeField(name: string, type = METRIC_TYPES.REAL, displayName: string | null = null): FieldInfo { return { name, type, display_name: displayName, unit: null, unit_abbrev: null, bigger_is_better: null }; } describe('filterMetricFields', () => { - it('returns only Real-typed fields', () => { + it('returns only real-typed fields', () => { const fields = [ - makeField('status', 'Status'), - makeField('compile_time', 'Real'), - makeField('exec_time', 'Real'), + makeField('status', METRIC_TYPES.STATUS), + makeField('compile_time', METRIC_TYPES.REAL), + makeField('exec_time', METRIC_TYPES.REAL), ]; const result = filterMetricFields(fields); expect(result).toHaveLength(2); expect(result.map(f => f.name)).toEqual(['compile_time', 'exec_time']); }); - it('returns empty array when no Real fields', () => { - const result = filterMetricFields([makeField('status', 'Status')]); + it('returns empty array when no real fields', () => { + const result = filterMetricFields([makeField('status', METRIC_TYPES.STATUS)]); expect(result).toHaveLength(0); }); }); @@ -37,8 +37,8 @@ describe('renderMetricSelector', () => { it('renders all fields passed to it', () => { const container = document.createElement('div'); renderMetricSelector(container, [ - makeField('compile_time', 'Real'), - makeField('exec_time', 'Real'), + makeField('compile_time'), + makeField('exec_time'), ], vi.fn()); const options = container.querySelectorAll('option'); @@ -48,8 +48,8 @@ describe('renderMetricSelector', () => { it('returns the first field name as initial metric', () => { const container = document.createElement('div'); const result = renderMetricSelector(container, [ - makeField('compile_time', 'Real'), - makeField('exec_time', 'Real'), + makeField('compile_time'), + makeField('exec_time'), ], vi.fn()); expect(result).toBe('compile_time'); @@ -58,7 +58,7 @@ describe('renderMetricSelector', () => { it('uses display_name when available', () => { const container = document.createElement('div'); renderMetricSelector(container, [ - makeField('ct', 'Real', 'Compile Time'), + makeField('ct', METRIC_TYPES.REAL, 'Compile Time'), ], vi.fn()); const option = container.querySelector('option'); @@ -69,7 +69,7 @@ describe('renderMetricSelector', () => { it('falls back to name when display_name is null', () => { const container = document.createElement('div'); renderMetricSelector(container, [ - makeField('exec_time', 'Real'), + makeField('exec_time'), ], vi.fn()); const option = container.querySelector('option'); @@ -80,8 +80,8 @@ describe('renderMetricSelector', () => { const onChange = vi.fn(); const container = document.createElement('div'); renderMetricSelector(container, [ - makeField('compile_time', 'Real'), - makeField('exec_time', 'Real'), + makeField('compile_time'), + makeField('exec_time'), ], onChange); const select = container.querySelector('select') as HTMLSelectElement; @@ -94,8 +94,8 @@ describe('renderMetricSelector', () => { it('shows placeholder option when placeholder: true', () => { const container = document.createElement('div'); const result = renderMetricSelector(container, [ - makeField('compile_time', 'Real'), - makeField('exec_time', 'Real'), + makeField('compile_time'), + makeField('exec_time'), ], vi.fn(), undefined, { placeholder: true }); const options = container.querySelectorAll('option'); @@ -108,8 +108,8 @@ describe('renderMetricSelector', () => { it('selects initialValue even with placeholder', () => { const container = document.createElement('div'); const result = renderMetricSelector(container, [ - makeField('compile_time', 'Real'), - makeField('exec_time', 'Real'), + makeField('compile_time'), + makeField('exec_time'), ], vi.fn(), 'exec_time', { placeholder: true }); expect(result).toBe('exec_time'); diff --git a/lnt/server/ui/v5/frontend/src/__tests__/pages/admin.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/pages/admin.test.ts index 40e10b19e..ef1dcecf6 100644 --- a/lnt/server/ui/v5/frontend/src/__tests__/pages/admin.test.ts +++ b/lnt/server/ui/v5/frontend/src/__tests__/pages/admin.test.ts @@ -50,11 +50,10 @@ const mockSuiteInfo: TestSuiteInfo = { name: 'nts', schema: { metrics: [ - { name: 'exec_time', type: 'Real', display_name: 'Execution Time', unit: 's', unit_abbrev: 's', bigger_is_better: false }, + { name: 'exec_time', type: 'real', display_name: 'Execution Time', unit: 's', unit_abbrev: 's', bigger_is_better: false }, ], - commit_fields: [{ name: 'rev', type: 'String' }], - machine_fields: [{ name: 'hostname', type: 'String' }], - run_fields: [], + commit_fields: [{ name: 'rev', type: 'text' }], + machine_fields: [{ name: 'hostname', type: 'text' }], }, }; diff --git a/lnt/server/ui/v5/frontend/src/__tests__/pages/compare.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/pages/compare.test.ts index 65a998e51..f0c1adb29 100644 --- a/lnt/server/ui/v5/frontend/src/__tests__/pages/compare.test.ts +++ b/lnt/server/ui/v5/frontend/src/__tests__/pages/compare.test.ts @@ -35,7 +35,7 @@ import { comparePage } from '../../pages/compare'; import type { FieldInfo, CommitSummary, SampleInfo } from '../../types'; const mockFields: FieldInfo[] = [ - { name: 'exec_time', type: 'Real', display_name: 'Execution Time', unit: 's', unit_abbrev: 's', bigger_is_better: false }, + { name: 'exec_time', type: 'real', display_name: 'Execution Time', unit: 's', unit_abbrev: 's', bigger_is_better: false }, ]; const mockCommits: CommitSummary[] = [ diff --git a/lnt/server/ui/v5/frontend/src/__tests__/pages/graph.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/pages/graph.test.ts index 133bc2aba..699a3aeac 100644 --- a/lnt/server/ui/v5/frontend/src/__tests__/pages/graph.test.ts +++ b/lnt/server/ui/v5/frontend/src/__tests__/pages/graph.test.ts @@ -449,9 +449,9 @@ describe('buildBaselinesFromData', () => { // --------------------------------------------------------------------------- const mockFields: FieldInfo[] = [ - { name: 'exec_time', type: 'Real', display_name: 'Execution Time', unit: 's', unit_abbrev: 's', bigger_is_better: false }, - { name: 'compile_time', type: 'Real', display_name: 'Compile Time', unit: 's', unit_abbrev: 's', bigger_is_better: false }, - { name: 'hash', type: 'Hash', display_name: 'Hash', unit: null, unit_abbrev: null, bigger_is_better: null }, + { name: 'exec_time', type: 'real', display_name: 'Execution Time', unit: 's', unit_abbrev: 's', bigger_is_better: false }, + { name: 'compile_time', type: 'real', display_name: 'Compile Time', unit: 's', unit_abbrev: 's', bigger_is_better: false }, + { name: 'hash', type: 'hash', display_name: 'Hash', unit: null, unit_abbrev: null, bigger_is_better: null }, ]; describe('graphPage mount', () => { diff --git a/lnt/server/ui/v5/frontend/src/__tests__/pages/home.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/pages/home.test.ts index ccea624d4..eccddea80 100644 --- a/lnt/server/ui/v5/frontend/src/__tests__/pages/home.test.ts +++ b/lnt/server/ui/v5/frontend/src/__tests__/pages/home.test.ts @@ -40,11 +40,10 @@ const mockSuiteInfo: TestSuiteInfo = { name: 'nts', schema: { metrics: [ - { name: 'execution_time', type: 'Real', display_name: 'Execution Time', unit: 'seconds', unit_abbrev: 's', bigger_is_better: false }, - { name: 'compile_time', type: 'Real', display_name: 'Compile Time', unit: 'seconds', unit_abbrev: 's', bigger_is_better: false }, + { name: 'execution_time', type: 'real', display_name: 'Execution Time', unit: 'seconds', unit_abbrev: 's', bigger_is_better: false }, + { name: 'compile_time', type: 'real', display_name: 'Compile Time', unit: 'seconds', unit_abbrev: 's', bigger_is_better: false }, ], - run_fields: [], - commit_fields: [{ name: 'llvm_project_revision', type: 'String' }], + commit_fields: [{ name: 'llvm_project_revision', type: 'text' }], machine_fields: [], }, }; @@ -53,10 +52,9 @@ const mockSuiteInfo2: TestSuiteInfo = { name: 'compile-suite', schema: { metrics: [ - { name: 'score', type: 'Real', display_name: 'Score', unit: null, unit_abbrev: null, bigger_is_better: true }, + { name: 'score', type: 'real', display_name: 'Score', unit: null, unit_abbrev: null, bigger_is_better: true }, ], - run_fields: [], - commit_fields: [{ name: 'revision', type: 'String' }], + commit_fields: [{ name: 'revision', type: 'text' }], machine_fields: [], }, }; diff --git a/lnt/server/ui/v5/frontend/src/__tests__/pages/run-detail.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/pages/run-detail.test.ts index 63bb00aef..f05b292d8 100644 --- a/lnt/server/ui/v5/frontend/src/__tests__/pages/run-detail.test.ts +++ b/lnt/server/ui/v5/frontend/src/__tests__/pages/run-detail.test.ts @@ -48,9 +48,9 @@ const mockRun: RunDetail = { }; const mockFields: FieldInfo[] = [ - { name: 'exec_time', type: 'Real', display_name: 'Execution Time', unit: 's', unit_abbrev: 's', bigger_is_better: false }, - { name: 'compile_time', type: 'Real', display_name: 'Compile Time', unit: 's', unit_abbrev: 's', bigger_is_better: false }, - { name: 'hash', type: 'Hash', display_name: 'Hash', unit: null, unit_abbrev: null, bigger_is_better: null }, + { name: 'exec_time', type: 'real', display_name: 'Execution Time', unit: 's', unit_abbrev: 's', bigger_is_better: false }, + { name: 'compile_time', type: 'real', display_name: 'Compile Time', unit: 's', unit_abbrev: 's', bigger_is_better: false }, + { name: 'hash', type: 'hash', display_name: 'Hash', unit: null, unit_abbrev: null, bigger_is_better: null }, ]; const mockSamples: SampleInfo[] = [ diff --git a/lnt/server/ui/v5/frontend/src/__tests__/selection.test.ts b/lnt/server/ui/v5/frontend/src/__tests__/selection.test.ts index 764768a03..ac4b2f7df 100644 --- a/lnt/server/ui/v5/frontend/src/__tests__/selection.test.ts +++ b/lnt/server/ui/v5/frontend/src/__tests__/selection.test.ts @@ -14,7 +14,7 @@ import type { FieldInfo } from '../types'; function makeField(overrides: Partial & { name: string }): FieldInfo { return { - type: 'Real', + type: 'real', display_name: null, unit: null, unit_abbrev: null, @@ -32,11 +32,11 @@ describe('getMetricFields', () => { (getCommits as ReturnType).mockResolvedValue([]); }); - it('returns only Real-typed fields', async () => { + it('returns only real-typed fields', async () => { const fields: FieldInfo[] = [ - makeField({ name: 'exec_time', type: 'Real' }), - makeField({ name: 'score', type: 'Real' }), - makeField({ name: 'hash', type: 'Status' }), + makeField({ name: 'exec_time', type: 'real' }), + makeField({ name: 'score', type: 'real' }), + makeField({ name: 'hash', type: 'status' }), ]; (getFields as ReturnType).mockResolvedValue(fields); @@ -48,10 +48,10 @@ describe('getMetricFields', () => { expect(result.map(f => f.name)).toEqual(['exec_time', 'score']); }); - it('excludes Status-typed fields', async () => { + it('excludes status-typed fields', async () => { const fields: FieldInfo[] = [ - makeField({ name: 'hash', type: 'Status' }), - makeField({ name: 'status_field', type: 'Status' }), + makeField({ name: 'hash', type: 'status' }), + makeField({ name: 'status_field', type: 'status' }), ]; (getFields as ReturnType).mockResolvedValue(fields); @@ -71,10 +71,10 @@ describe('getMetricFields', () => { it('preserves field order from input', async () => { const fields: FieldInfo[] = [ - makeField({ name: 'z_metric', type: 'Real' }), - makeField({ name: 'non_metric', type: 'Status' }), - makeField({ name: 'a_metric', type: 'Real' }), - makeField({ name: 'm_metric', type: 'Real' }), + makeField({ name: 'z_metric', type: 'real' }), + makeField({ name: 'non_metric', type: 'status' }), + makeField({ name: 'a_metric', type: 'real' }), + makeField({ name: 'm_metric', type: 'real' }), ]; (getFields as ReturnType).mockResolvedValue(fields); diff --git a/lnt/server/ui/v5/frontend/src/components/metric-selector.ts b/lnt/server/ui/v5/frontend/src/components/metric-selector.ts index a9c94d163..3cd807828 100644 --- a/lnt/server/ui/v5/frontend/src/components/metric-selector.ts +++ b/lnt/server/ui/v5/frontend/src/components/metric-selector.ts @@ -3,9 +3,15 @@ import { el } from '../utils'; import type { FieldInfo } from '../types'; -/** Filter fields to only plottable numeric metrics (type === 'Real'). */ +/** + * Valid v5 metric types. Must match the backend's VALID_METRIC_TYPES + * in lnt/server/db/v5/schema.py. + */ +export const METRIC_TYPES = { REAL: 'real', STATUS: 'status', HASH: 'hash' } as const; + +/** Filter fields to only plottable numeric metrics (type === 'real'). */ export function filterMetricFields(fields: FieldInfo[]): FieldInfo[] { - return fields.filter(f => f.type === 'Real'); + return fields.filter(f => f.type === METRIC_TYPES.REAL); } export interface MetricSelectorOptions { diff --git a/lnt/server/ui/v5/frontend/src/pages/admin.ts b/lnt/server/ui/v5/frontend/src/pages/admin.ts index 833f645c2..ff979e4a1 100644 --- a/lnt/server/ui/v5/frontend/src/pages/admin.ts +++ b/lnt/server/ui/v5/frontend/src/pages/admin.ts @@ -509,7 +509,6 @@ function renderSchemaContent(container: HTMLElement, info: TestSuiteInfo): void for (const [label, fields] of [ ['Commit Fields', info.schema.commit_fields], ['Machine Fields', info.schema.machine_fields], - ['Run Fields', info.schema.run_fields], ] as const) { if (fields && fields.length > 0) { container.append(el('h4', {}, label)); diff --git a/lnt/server/ui/v5/frontend/src/pages/home.ts b/lnt/server/ui/v5/frontend/src/pages/home.ts index b73dc34f0..7c74c6dbd 100644 --- a/lnt/server/ui/v5/frontend/src/pages/home.ts +++ b/lnt/server/ui/v5/frontend/src/pages/home.ts @@ -6,6 +6,7 @@ import type { FieldInfo } from '../types'; import { getTestsuites } from '../router'; import { getTestSuiteInfo, getRunsPage, fetchTrends } from '../api'; import { el, agnosticUrl } from '../utils'; +import { filterMetricFields } from '../components/metric-selector'; import type { SparklineTrace } from '../components/sparkline-card'; import { createSparklineCard, createSparklineLoading, createSparklineError, @@ -173,9 +174,7 @@ export const homePage: PageModule = { if (sig.aborted) return; - const metrics = suiteInfo.schema.metrics.filter( - m => m.type === 'Real' || m.type === 'Integer', - ); + const metrics = filterMetricFields(suiteInfo.schema.metrics); if (metrics.length === 0) { grid.append(el('p', { class: 'sparkline-loading' }, 'No metrics defined.')); return; diff --git a/lnt/server/ui/v5/frontend/src/types.ts b/lnt/server/ui/v5/frontend/src/types.ts index 369ae2dd2..302f863d6 100644 --- a/lnt/server/ui/v5/frontend/src/types.ts +++ b/lnt/server/ui/v5/frontend/src/types.ts @@ -164,7 +164,6 @@ export interface TestSuiteInfo { name: string; schema: { metrics: FieldInfo[]; - run_fields: Array<{ name: string; type: string }>; commit_fields: Array<{ name: string; type: string; display?: boolean }>; machine_fields: Array<{ name: string; type: string }>; }; From cbbef6800ffa0013d11f0de9a78e42f9737b44cf Mon Sep 17 00:00:00 2001 From: Louis Dionne Date: Wed, 15 Apr 2026 16:01:33 -0400 Subject: [PATCH 073/143] [UI] Return 404 for nonexistent test suites in v5 SPA catch-all The v5_app() catch-all route served the SPA shell for any URL matching /v5//..., even when the test suite didn't exist. This caused broken pages instead of proper 404 responses. Co-Authored-By: Claude Opus 4.6 (1M context) --- lnt/server/ui/v5/views.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/lnt/server/ui/v5/views.py b/lnt/server/ui/v5/views.py index ce87293cd..3ce142170 100644 --- a/lnt/server/ui/v5/views.py +++ b/lnt/server/ui/v5/views.py @@ -1,4 +1,4 @@ -from flask import g, render_template, request +from flask import abort, g, render_template, request from . import v5_frontend, _setup_testsuite from lnt.server.ui.decorators import _make_db_session @@ -67,6 +67,8 @@ def v5_app(testsuite_name, subpath=None): _setup_testsuite(testsuite_name) try: db = request.get_db() + if testsuite_name not in db.testsuite: + abort(404) return _v5_render(testsuites=sorted(db.testsuite.keys())) finally: request.session.close() From 520630c1419e13d97d04755e45b23dc852e7940a Mon Sep 17 00:00:00 2001 From: Louis Dionne Date: Wed, 15 Apr 2026 16:23:19 -0400 Subject: [PATCH 074/143] [UI] Implement regression list, detail, and cross-page integration Replace regression list and detail page stubs with full implementations. Add cross-page regression sections to machine detail, run detail, commit detail, graph page (annotation overlays), and compare page (add to regression panel). Remove dead field-change-triage stub page. Includes regression API client, shared state constants, auth-gated mutation controls, CSS, and 57 vitest tests (23 list, 34 detail). Co-Authored-By: Claude Opus 4.6 (1M context) --- docs/v5-regression-ui-implementation-plan.md | 1871 +++++++++++++++++ .../__tests__/pages/regression-detail.test.ts | 725 +++++++ .../__tests__/pages/regression-list.test.ts | 557 +++++ lnt/server/ui/v5/frontend/src/api.ts | 141 +- .../src/components/time-series-chart.ts | 15 +- lnt/server/ui/v5/frontend/src/main.ts | 2 - .../ui/v5/frontend/src/pages/commit-detail.ts | 65 +- .../ui/v5/frontend/src/pages/compare.ts | 246 ++- .../frontend/src/pages/field-change-triage.ts | 13 - lnt/server/ui/v5/frontend/src/pages/graph.ts | 120 +- .../v5/frontend/src/pages/machine-detail.ts | 63 +- .../frontend/src/pages/regression-detail.ts | 653 +++++- .../v5/frontend/src/pages/regression-list.ts | 407 +++- .../ui/v5/frontend/src/pages/run-detail.ts | 62 +- .../ui/v5/frontend/src/regression-utils.ts | 38 + lnt/server/ui/v5/frontend/src/style.css | 327 +++ lnt/server/ui/v5/frontend/src/types.ts | 38 + 17 files changed, 5296 insertions(+), 47 deletions(-) create mode 100644 docs/v5-regression-ui-implementation-plan.md create mode 100644 lnt/server/ui/v5/frontend/src/__tests__/pages/regression-detail.test.ts create mode 100644 lnt/server/ui/v5/frontend/src/__tests__/pages/regression-list.test.ts delete mode 100644 lnt/server/ui/v5/frontend/src/pages/field-change-triage.ts create mode 100644 lnt/server/ui/v5/frontend/src/regression-utils.ts diff --git a/docs/v5-regression-ui-implementation-plan.md b/docs/v5-regression-ui-implementation-plan.md new file mode 100644 index 000000000..a1209626c --- /dev/null +++ b/docs/v5-regression-ui-implementation-plan.md @@ -0,0 +1,1871 @@ +# v5 Regression UI — Implementation Plan + +This document is a step-by-step implementation plan for the Regression List page, Regression Detail page, and cross-page regression integration in the v5 Web UI. Each phase includes exact file paths, type definitions, function signatures, component structure, CSS class names, and testing strategy. The plan assumes the reader has already read `docs/design/v5-ui.md` (sections 8-9 and the cross-page integration notes) and is familiar with the existing frontend source in `lnt/server/ui/v5/frontend/src/`. + +## Prerequisite Reading + +Before starting, read: +- `docs/design/v5-ui.md` — sections 8 (Regression List), 9 (Regression Detail), and the Cross-Page Integration notes +- `lnt/server/api/v5/endpoints/regressions.py` — the full API implementation +- `lnt/server/api/v5/schemas/regressions.py` — request/response schemas and state constants +- All existing frontend components in `lnt/server/ui/v5/frontend/src/components/` +- Existing page implementations (`machine-detail.ts`, `run-detail.ts`, `commit-detail.ts`) for patterns + +--- + +## Phase 1: Types & API Functions + +**Goal**: Add TypeScript interfaces for regression and indicator types to `types.ts`, and add API client functions for all 7 regression endpoints to `api.ts`. No UI changes in this phase. + +### 1.1 Regression Types + +**File**: `lnt/server/ui/v5/frontend/src/types.ts` (extend existing) + +Add the following interfaces at the end of the file, after the existing `TestSuiteInfo` interface: + +```typescript +// Regression types + +export type RegressionState = + | 'detected' + | 'active' + | 'not_to_be_fixed' + | 'fixed' + | 'false_positive'; + +export interface RegressionIndicator { + uuid: string; + machine: string; + test: string; + metric: string; +} + +/** Regression as returned by GET /regressions (list endpoint). */ +export interface RegressionListItem { + uuid: string; + title: string | null; + bug: string | null; + state: RegressionState; + commit: string | null; + machine_count: number; + test_count: number; +} + +/** Regression as returned by GET /regressions/{uuid} (detail endpoint). */ +export interface RegressionDetail { + uuid: string; + title: string | null; + bug: string | null; + notes: string | null; + state: RegressionState; + commit: string | null; + indicators: RegressionIndicator[]; +} +``` + +**Implementation notes**: +- `RegressionState` is a union type matching the 5 valid states in `lnt/server/api/v5/schemas/regressions.py` (`STATE_TO_DB` keys). +- `RegressionListItem` matches the shape from `_serialize_regression_list()` in `regressions.py`. +- `RegressionDetail` matches `_serialize_regression_detail()` — includes `notes` and embedded `indicators` array. +- Both `RegressionListItem` and `RegressionDetail` share the base fields from `_serialize_regression_base()`. + +### 1.2 Regression API Functions + +**File**: `lnt/server/ui/v5/frontend/src/api.ts` (extend existing) + +Add the following imports at the top (extend the existing `import type` statement): + +```typescript +import type { + // ... existing imports ... + RegressionListItem, RegressionDetail, RegressionState, +} from './types'; +``` + +Add the following functions after the existing admin API functions, in a new `// Regressions` section: + +```typescript +// --------------------------------------------------------------------------- +// Regressions +// --------------------------------------------------------------------------- + +/** Query parameters for listing regressions. */ +export interface RegressionListParams { + state?: RegressionState[]; + machine?: string; + test?: string; + metric?: string; + commit?: string; + has_commit?: boolean; + cursor?: string; + limit?: number; +} + +/** Fetch one page of regressions with optional filters. */ +export async function getRegressions( + ts: string, + opts?: RegressionListParams, + signal?: AbortSignal, +): Promise> { + const params: Record = {}; + if (opts?.state?.length) params.state = opts.state.join(','); + if (opts?.machine) params.machine = opts.machine; + if (opts?.test) params.test = opts.test; + if (opts?.metric) params.metric = opts.metric; + if (opts?.commit) params.commit = opts.commit; + if (opts?.has_commit === true) params.has_commit = 'true'; + if (opts?.has_commit === false) params.has_commit = 'false'; + if (opts?.limit !== undefined) params.limit = String(opts.limit); + if (opts?.cursor) params.cursor = opts.cursor; + return fetchOneCursorPage( + apiUrl(ts, 'regressions'), params, signal); +} + +/** Fetch all regressions matching filters (auto-paginate). */ +export async function getAllRegressions( + ts: string, + opts?: Omit, + signal?: AbortSignal, +): Promise { + const params: Record = {}; + if (opts?.state?.length) params.state = opts.state.join(','); + if (opts?.machine) params.machine = opts.machine; + if (opts?.test) params.test = opts.test; + if (opts?.metric) params.metric = opts.metric; + if (opts?.commit) params.commit = opts.commit; + if (opts?.has_commit === true) params.has_commit = 'true'; + if (opts?.has_commit === false) params.has_commit = 'false'; + return fetchAllCursorPages( + apiUrl(ts, 'regressions'), params, signal); +} + +/** Create a new regression. */ +export async function createRegression( + ts: string, + body: { + title?: string; + bug?: string; + notes?: string; + state?: RegressionState; + commit?: string; + indicators?: Array<{ machine: string; test: string; metric: string }>; + }, + signal?: AbortSignal, +): Promise { + return fetchJson( + apiUrl(ts, 'regressions'), + { method: 'POST', body, signal }, + ); +} + +/** Fetch a single regression by UUID. */ +export async function getRegression( + ts: string, + uuid: string, + signal?: AbortSignal, +): Promise { + return fetchJson( + apiUrl(ts, `regressions/${encodeURIComponent(uuid)}`), + { signal }, + ); +} + +/** Update regression fields (PATCH — only included fields are changed). */ +export async function updateRegression( + ts: string, + uuid: string, + updates: { + title?: string; + bug?: string | null; + notes?: string | null; + state?: RegressionState; + commit?: string | null; + }, + signal?: AbortSignal, +): Promise { + return fetchJson( + apiUrl(ts, `regressions/${encodeURIComponent(uuid)}`), + { method: 'PATCH', body: updates, signal }, + ); +} + +/** Delete a regression. */ +export async function deleteRegression( + ts: string, + uuid: string, + signal?: AbortSignal, +): Promise { + return fetchVoid( + apiUrl(ts, `regressions/${encodeURIComponent(uuid)}`), + { method: 'DELETE', signal }, + ); +} + +/** Add indicators to a regression (batch). Returns updated detail. */ +export async function addRegressionIndicators( + ts: string, + regressionUuid: string, + indicators: Array<{ machine: string; test: string; metric: string }>, + signal?: AbortSignal, +): Promise { + return fetchJson( + apiUrl(ts, `regressions/${encodeURIComponent(regressionUuid)}/indicators`), + { method: 'POST', body: { indicators }, signal }, + ); +} + +/** Remove indicators from a regression (batch, by UUID). Returns updated detail. */ +export async function removeRegressionIndicators( + ts: string, + regressionUuid: string, + indicatorUuids: string[], + signal?: AbortSignal, +): Promise { + return fetchJson( + apiUrl(ts, `regressions/${encodeURIComponent(regressionUuid)}/indicators`), + { method: 'DELETE', body: { indicator_uuids: indicatorUuids }, signal }, + ); +} +``` + +**Implementation notes**: +- `getRegressions` uses `fetchOneCursorPage` for manual cursor control (matching the pattern from `getRunsPage`, `getCommitsPage`). +- `getAllRegressions` uses `fetchAllCursorPages` for auto-pagination (useful for cross-page integration where we need all matching regressions). +- `removeRegressionIndicators` uses `fetchJson` (not `fetchVoid`) because the DELETE endpoint returns the updated regression detail (200, not 204). This matches the API behavior in `regressions.py` line 402-420. +- The `state` parameter is serialized as a comma-separated string matching the `DelimitedList` field in `RegressionListQuerySchema`. + +### 1.3 State Display Constants + +**File**: `lnt/server/ui/v5/frontend/src/pages/regression-list.ts` (will be replaced in Phase 2, but define constants here that Phase 3 also reuses) + +Since both the list and detail pages need state display metadata, define a shared module: + +**File**: `lnt/server/ui/v5/frontend/src/regression-utils.ts` (new file) + +```typescript +// regression-utils.ts — Shared constants and helpers for regression pages. + +import type { RegressionState } from './types'; + +/** Display metadata for each regression state. */ +export const STATE_META: Record = { + detected: { label: 'Detected', cssClass: 'state-detected' }, + active: { label: 'Active', cssClass: 'state-active' }, + not_to_be_fixed: { label: 'Not To Be Fixed', cssClass: 'state-not-to-be-fixed' }, + fixed: { label: 'Fixed', cssClass: 'state-fixed' }, + false_positive: { label: 'False Positive', cssClass: 'state-false-positive' }, +}; + +/** All valid regression states in display order. */ +export const ALL_STATES: RegressionState[] = [ + 'detected', 'active', 'not_to_be_fixed', 'fixed', 'false_positive', +]; + +/** Resolved states (these are considered "closed"). */ +export const RESOLVED_STATES: RegressionState[] = [ + 'not_to_be_fixed', 'fixed', 'false_positive', +]; + +/** Non-resolved states (these are "open" / active). */ +export const UNRESOLVED_STATES: RegressionState[] = [ + 'detected', 'active', +]; +``` + +### 1.4 Phase 1 Testing + +**File**: `lnt/server/ui/v5/frontend/src/__tests__/api.test.ts` (extend existing) + +Add tests for each of the 7 regression API functions. Follow the existing pattern in `api.test.ts` which uses `vi.stubGlobal('fetch', mockFetch)` and verifies URL construction, HTTP method, request body, and response parsing. + +Tests to add: +- `getRegressions` — verifies URL is `{base}/api/v5/{ts}/regressions`, state param is comma-joined, limit/cursor forwarded +- `getRegressions` with empty opts — no query params +- `getAllRegressions` — verifies multi-page fetch (mock two pages) +- `createRegression` — POST method, JSON body with title/state/commit/indicators +- `getRegression` — GET with UUID in path +- `updateRegression` — PATCH method, JSON body, UUID in path +- `deleteRegression` — DELETE method, UUID in path, no response body parsing +- `addRegressionIndicators` — POST to `/indicators` sub-path, body has `indicators` array +- `removeRegressionIndicators` — DELETE to `/indicators` sub-path, body has `indicator_uuids` array, returns `RegressionDetail` + +--- + +## Phase 2: Regression List Page + +**Goal**: Replace the stub in `regression-list.ts` with a full implementation: state filter chips, machine/test/metric filters, sortable data table, cursor pagination, create form, and per-row delete. + +### 2.1 Regression List Page Module + +**File**: `lnt/server/ui/v5/frontend/src/pages/regression-list.ts` (replace stub) + +**Structure**: The page follows the standard PageModule pattern with `mount(container, params)` and `unmount()`. An `AbortController` manages all async operations and is aborted on unmount. + +```typescript +import type { PageModule, RouteParams } from '../router'; +import type { RegressionListItem, RegressionState, FieldInfo } from '../types'; +import { + getRegressions, createRegression, deleteRegression, getFields, + apiUrl, authErrorMessage, CursorPageResult, +} from '../api'; +import { el, spaLink, truncate, debounce } from '../utils'; +import { navigate } from '../router'; +import { renderDataTable, type Column } from '../components/data-table'; +import { renderPagination } from '../components/pagination'; +import { renderMachineCombobox } from '../components/machine-combobox'; +import { renderMetricSelector, filterMetricFields } from '../components/metric-selector'; +import { ALL_STATES, STATE_META } from '../regression-utils'; + +const PAGE_SIZE = 25; + +let controller: AbortController | null = null; +let machineComboCleanup: (() => void) | null = null; + +export const regressionListPage: PageModule = { + mount(container: HTMLElement, params: RouteParams): void { ... }, + unmount(): void { + controller?.abort(); + machineComboCleanup?.(); + }, +}; +``` + +**DOM layout** (created in `mount`): + +``` +

    Regressions

    +
    ← Filter control panel +
    ← State filter chips +
    ← Machine, test, metric, has_commit +
    ← Title search +
    +
    ← "New Regression" button +
    ← Collapsible create form +
    ← Error messages +
    ← Data table +
    ← Pagination controls +``` + +**Auth scope gating**: The "New Regression" button, per-row delete actions, and the create form require `triage` scope. Check whether a token is available via `getToken()` (from `api.ts`). If no token is set, hide mutation controls entirely. If a mutation request returns 401/403, display the error via `authErrorMessage(err)`. This pattern matches the existing admin page which hides controls for unauthenticated users. + +### 2.2 State Filter Chips + +Render inside `.state-chips` as toggle buttons. Each chip is a `` rendered in `.regression-actions`. Clicking it toggles visibility of `.create-form-container`. + +The create form contains: +- Title: `` +- State: `` +- Commit: Use `renderCommitSearch` from `components/commit-search.ts` with `onSelect` callback +- Buttons: "Create" (`` + +Edit mode: `` + `` + `` + +On save: +```typescript +updateRegression(ts, uuid, { title: inputValue }, signal) + .then(updated => { regression = updated; rerenderTitle(); }) + .catch(err => showError(authErrorMessage(err))); +``` + +#### State (always-visible dropdown) + +Rendered as a `` + Save/Cancel buttons. + +On save: `updateRegression(ts, uuid, { bug: inputValue || null })` — empty string maps to `null` (clear). + +#### Commit (combobox, nullable) + +Display mode: If commit is set, show `spaLink(commit, '/commits/...')` + `` + ``. If null, show "(none)" + "Set" button. + +Edit mode: Use `renderCommitSearch` from `components/commit-search.ts` with `onSelect` callback. The `onSelect` callback calls `updateRegression(ts, uuid, { commit: value })`. **Cleanup**: `renderCommitSearch` returns `{ destroy, setSuggestions }` — push `destroy` into `cleanupFns` so it is called on unmount (prevents document-level click listener leaks). + +Clear button calls `updateRegression(ts, uuid, { commit: null })`. + +#### Notes (expandable textarea) + +Always visible as a `