Buckets:

download
raw
10.2 kB
#!/usr/bin/env python3
"""Seed the E2E test database with auth-separation test data.
Inserts the admin user directly into PG (bypassing the API bootstrap
chicken-and-egg), then uses the REST API to create a viewer, service
accounts, models, and model-access grants.
Writes seed data to frontend/e2e/.seed-data.json for Playwright to consume.
Usage:
python scripts/seed_e2e_auth.py [--base-url http://localhost:8001]
"""
import argparse
import json
import os
import sys
import time
from datetime import UTC, datetime, timedelta
from pathlib import Path
import httpx
import psycopg2
from yaai.server.auth.passwords import hash_password
# Defaults matching docker-compose.test.yml
DEFAULT_BASE_URL = "http://localhost:8001"
PG_DSN = "postgresql://aimon:testpass@localhost:5433/aimonitoring_test"
OWNER_USERNAME = "admin"
OWNER_PASSWORD = os.environ.get("E2E_OWNER_PASSWORD", "owner-pass-123")
OWNER_EMAIL = "admin@e2e-test.local"
VIEWER_USERNAME = "viewer"
VIEWER_PASSWORD = os.environ.get("E2E_VIEWER_PASSWORD", "viewer-pass-123")
VIEWER_EMAIL = "viewer@e2e-test.local"
def _wait_for_health(base_url: str, retries: int = 30, interval: float = 2.0) -> None:
"""Poll /health until the backend is ready."""
url = f"{base_url}/health"
for i in range(retries):
try:
r = httpx.get(url, timeout=5)
if r.status_code == 200:
print(f" Backend healthy after {i + 1} attempt(s)")
return
except httpx.ConnectError:
pass
time.sleep(interval)
print("ERROR: Backend did not become healthy", file=sys.stderr)
sys.exit(1)
def _clean_db(dsn: str) -> None:
"""Truncate all application tables so the seed is idempotent."""
conn = psycopg2.connect(dsn)
try:
with conn.cursor() as cur:
cur.execute(
"""
TRUNCATE model_access, api_keys, service_accounts,
refresh_tokens, drift_results, notifications,
job_runs, job_configs, ground_truth,
reference_data, inference_data, schema_fields,
model_versions, models, users
CASCADE
"""
)
conn.commit()
print(" Cleaned all application tables")
finally:
conn.close()
def _insert_admin_user(dsn: str) -> None:
"""Insert the admin user directly into PG using bcrypt-hashed password."""
hashed = hash_password(OWNER_PASSWORD)
conn = psycopg2.connect(dsn)
try:
with conn.cursor() as cur:
cur.execute("SELECT id FROM users WHERE username = %s", (OWNER_USERNAME,))
if cur.fetchone():
print(f" Admin user '{OWNER_USERNAME}' already exists, skipping insert")
return
cur.execute(
"""
INSERT INTO users (id, username, email, hashed_password, role, auth_provider, is_active, created_at, updated_at)
VALUES (gen_random_uuid(), %s, %s, %s, 'OWNER', 'LOCAL', true, now(), now())
""",
(OWNER_USERNAME, OWNER_EMAIL, hashed),
)
conn.commit()
print(f" Inserted admin user '{OWNER_USERNAME}'")
finally:
conn.close()
def _login(client: httpx.Client, base_url: str, username: str, password: str) -> str:
"""Login and return the access token."""
r = client.post(
f"{base_url}/api/v1/auth/login",
json={"username": username, "password": password},
)
assert r.status_code == 200, f"Login failed for {username}: {r.status_code} {r.text}"
return r.json()["data"]["access_token"]
def _auth_headers(token: str) -> dict:
return {"Authorization": f"Bearer {token}"}
def main() -> None:
parser = argparse.ArgumentParser(description="Seed E2E auth test data")
parser.add_argument("--base-url", default=DEFAULT_BASE_URL)
parser.add_argument("--pg-dsn", default=PG_DSN)
args = parser.parse_args()
base_url = args.base_url.rstrip("/")
print("1. Waiting for backend health...")
_wait_for_health(base_url)
print("2. Cleaning existing data (idempotent re-run)...")
_clean_db(args.pg_dsn)
print("3. Inserting admin user directly into PG...")
_insert_admin_user(args.pg_dsn)
client = httpx.Client(timeout=30.0)
print("4. Logging in as admin...")
admin_token = _login(client, base_url, OWNER_USERNAME, OWNER_PASSWORD)
headers = _auth_headers(admin_token)
print("5. Creating viewer user...")
r = client.post(
f"{base_url}/api/v1/auth/users",
json={
"username": VIEWER_USERNAME,
"password": VIEWER_PASSWORD,
"email": VIEWER_EMAIL,
"role": "viewer",
},
headers=headers,
)
assert r.status_code in (201, 409), f"Create viewer failed: {r.status_code} {r.text}"
print("6. Creating service accounts...")
sa1_resp = client.post(
f"{base_url}/api/v1/auth/service-accounts",
json={"name": "e2e-sa-1", "auth_type": "api_key"},
headers=headers,
)
assert sa1_resp.status_code == 201, f"Create SA-1 failed: {sa1_resp.text}"
sa1_data = sa1_resp.json()["data"]
sa1_id = sa1_data["service_account"]["id"]
sa1_key = sa1_data["raw_key"]
print(f" SA-1: {sa1_id}")
sa2_resp = client.post(
f"{base_url}/api/v1/auth/service-accounts",
json={"name": "e2e-sa-2", "auth_type": "api_key"},
headers=headers,
)
assert sa2_resp.status_code == 201, f"Create SA-2 failed: {sa2_resp.text}"
sa2_data = sa2_resp.json()["data"]
sa2_id = sa2_data["service_account"]["id"]
sa2_key = sa2_data["raw_key"]
print(f" SA-2: {sa2_id}")
print("7. Creating models...")
model_a_resp = client.post(
f"{base_url}/api/v1/models",
json={"name": "E2E-Model-A"},
headers=headers,
)
assert model_a_resp.status_code == 201, f"Create Model-A failed: {model_a_resp.text}"
model_a_id = model_a_resp.json()["data"]["id"]
print(f" Model-A: {model_a_id}")
model_b_resp = client.post(
f"{base_url}/api/v1/models",
json={"name": "E2E-Model-B"},
headers=headers,
)
assert model_b_resp.status_code == 201, f"Create Model-B failed: {model_b_resp.text}"
model_b_id = model_b_resp.json()["data"]["id"]
print(f" Model-B: {model_b_id}")
print("8. Granting model access...")
r = client.post(
f"{base_url}/api/v1/auth/models/{model_a_id}/access",
json={"service_account_id": sa1_id},
headers=headers,
)
assert r.status_code == 201, f"Grant SA-1 -> Model-A failed: {r.text}"
print(" SA-1 -> Model-A")
r = client.post(
f"{base_url}/api/v1/auth/models/{model_b_id}/access",
json={"service_account_id": sa2_id},
headers=headers,
)
assert r.status_code == 201, f"Grant SA-2 -> Model-B failed: {r.text}"
print(" SA-2 -> Model-B")
print("9. Creating version on Model-A with schema...")
r = client.post(
f"{base_url}/api/v1/models/{model_a_id}/versions",
json={
"version": "v1.0",
"schema": [
{"direction": "input", "field_name": "age", "data_type": "numerical"},
{"direction": "input", "field_name": "gender", "data_type": "categorical"},
{"direction": "output", "field_name": "score", "data_type": "numerical"},
],
},
headers=headers,
)
assert r.status_code == 201, f"Create version failed: {r.text}"
version_a_id = r.json()["data"]["id"]
print(f" Version: {version_a_id}")
print("10. Uploading reference data (100 records)...")
ref_records = [
{
"inputs": {"age": 25 + i, "gender": "male" if i % 2 == 0 else "female"},
"outputs": {"score": 0.5},
}
for i in range(100)
]
r = client.post(
f"{base_url}/api/v1/models/{model_a_id}/versions/{version_a_id}/reference-data",
json={"records": ref_records},
headers=headers,
)
assert r.status_code == 201, f"Upload reference data failed: {r.text}"
print("11. Ingesting inference data (shifted ages for drift)...")
now = datetime.now(UTC)
for i in range(100):
client.post(
f"{base_url}/api/v1/inferences",
json={
"model_version_id": version_a_id,
"inputs": {"age": 200 + i, "gender": "male" if i % 2 == 0 else "female"},
"outputs": {"score": 0.5},
"timestamp": (now - timedelta(minutes=i)).isoformat(),
},
headers=headers,
)
print("12. Triggering drift detection...")
r = client.get(
f"{base_url}/api/v1/models/{model_a_id}/versions/{version_a_id}/jobs",
headers=headers,
)
assert r.status_code == 200, f"List jobs failed: {r.text}"
job_a_id = r.json()["data"][0]["id"]
print(f" Job: {job_a_id}")
r = client.post(f"{base_url}/api/v1/jobs/{job_a_id}/trigger", headers=headers)
assert r.status_code == 201, f"Trigger job failed: {r.text}"
run_status = r.json()["data"]["status"]
print(f" Drift run status: {run_status}")
seed_data = {
"owner": {"username": OWNER_USERNAME, "password": OWNER_PASSWORD},
"viewer": {"username": VIEWER_USERNAME, "password": VIEWER_PASSWORD},
"sa1": {"id": sa1_id, "key": sa1_key, "name": "e2e-sa-1"},
"sa2": {"id": sa2_id, "key": sa2_key, "name": "e2e-sa-2"},
"model_a": {"id": model_a_id, "name": "E2E-Model-A"},
"model_b": {"id": model_b_id, "name": "E2E-Model-B"},
"version_a": {"id": version_a_id, "version": "v1.0"},
"job_a": {"id": job_a_id},
}
out_path = Path(__file__).resolve().parent.parent / "frontend" / "e2e" / ".seed-data.json"
out_path.parent.mkdir(parents=True, exist_ok=True)
out_path.write_text(json.dumps(seed_data, indent=2) + "\n")
print(f"13. Wrote seed data to {out_path}")
client.close()
print("Done.")
if __name__ == "__main__":
main()

Xet Storage Details

Size:
10.2 kB
·
Xet hash:
35050ac706a927b9113b3fec5a3676b59cfdcd29fc075508ec5156cf2b353e3d

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.