"""Private, disposable local API runtime for integration acceptance tests.""" from contextlib import contextmanager import http.cookiejar import json import os from pathlib import Path import secrets import signal import socket import subprocess import sys import uuid from urllib.error import HTTPError from urllib.request import Request, build_opener, HTTPCookieProcessor ROOT = Path(__file__).resolve().parents[1] sys.path.insert(0, str(ROOT / 'scripts')) import project import backup import managed_test_resources as test_resources sys.path.insert(0, str(ROOT / 'verification')) from benchmark_scale import clone_database, ident, sql class LocalApi: def __init__(self, port, username=None, password=None): if port not in (5281, 5283, 5284, 5285, 5287): raise ValueError('Only fixed project loopback ports are allowed') self.base = f'http://127.0.0.1:{port}' self.opener = build_opener(HTTPCookieProcessor(http.cookiejar.CookieJar())) self.csrf = None if username is not None: status, response, _ = self.call('/api/auth/csrf') if status != 200: raise RuntimeError('CSRF initialization failed') self.csrf = response['token'] status, _, _ = self.call('/api/auth/login', {'username': username, 'password': password}) if status != 200: raise RuntimeError('Local test authentication failed') _, response, _ = self.call('/api/auth/csrf') self.csrf = response['token'] def call(self, path, payload=None, method=None, binary=False): if not path.startswith('/api/') or '://' in path: raise ValueError('Only local API paths are allowed') headers = {'Accept': 'application/json'} if self.csrf: headers['X-XSRF-TOKEN'] = self.csrf if payload is not None: headers['Content-Type'] = 'application/json' request = Request(self.base + path, method=method or ('POST' if payload is not None else 'GET'), headers=headers, data=json.dumps(payload, ensure_ascii=False).encode() if payload is not None else None) try: with self.opener.open(request, timeout=180) as response: data = response.read() return response.status, data if binary else json.loads(data) if data else {}, dict(response.headers) except HTTPError as failure: raw = failure.read() try: body = json.loads(raw) except (ValueError, UnicodeDecodeError): body = {'detail': 'Non-JSON error response'} return failure.code, body, dict(failure.headers) @contextmanager def isolated_api(port=5284, fresh=False, evidence_dir=None, current_release_only=False, product_scope=None, env_overrides=None, auth_credentials=None): with socket.socket() as probe: if probe.connect_ex(('127.0.0.1', port)) == 0: raise RuntimeError('The integration port is already in use') if product_scope is not None and (not isinstance(product_scope,str) or not product_scope.strip() or len(product_scope)>256): raise ValueError('Invalid isolated product scope') allowed_overrides = {'QUALITY_NAO_MODEL_CONFIG_FILE', 'QUALITY_MODEL_CONFIG', 'QUALITY_ARCHIVE_ROOT', 'QUALITY_ANALYSIS_MODEL_CONFIG_FILE', 'QUALITY_ANALYSIS_RUNTIME_SCRIPT', 'QUALITY_ANALYSIS_STATE_DIR', 'SERVER_SERVLET_SESSION_COOKIE_NAME', 'QUALITY_ANALYSIS_PROTOCOL_V1_ENABLED', 'QUALITY_ANALYSIS_AUTONOMOUS_ENABLED'} if env_overrides is not None and (not isinstance(env_overrides, dict) or not set(env_overrides).issubset(allowed_overrides) or any(not isinstance(key, str) or not isinstance(value, str) for key, value in env_overrides.items())): raise ValueError('Invalid isolated runtime environment override') if auth_credentials is not None and (not isinstance(auth_credentials, tuple) or len(auth_credentials) != 2 or any(not isinstance(value, str) or not value for value in auth_credentials)): raise ValueError('Invalid isolated test login credentials') config = project.config() database = 'quality_verify_' + uuid.uuid4().hex[:16] account = 'qverify_' + uuid.uuid4().hex[:12] password = secrets.token_urlsafe(32) process = None db_created = user_created = False evidence = {'database': database, 'port': port, 'freshInstallation': fresh, 'factScope': ('currentReleaseProduct' if current_release_only else 'product') if product_scope is not None else 'currentRelease' if current_release_only else 'all', 'cleanup': {}} out = Path(evidence_dir) if evidence_dir is not None else ROOT / 'output/completion' out.mkdir(parents=True, exist_ok=True) if evidence_dir is not None: out.chmod(0o700) try: evidence['livePointerBefore'] = sql("SELECT release_id FROM current_release WHERE dataset_id='quality';", config['mysqlDatabase']).strip() sql(f'CREATE DATABASE {ident(database)} CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci;', empty=fresh) db_created = True if not fresh: clone_database(config['mysqlDatabase'], database) for table in ('fact_black', 'fact_bright'): predicate = (f" WHERE EXISTS (SELECT 1 FROM {ident(config['mysqlDatabase'])}.release_member rm " f"JOIN {ident(config['mysqlDatabase'])}.current_release cr ON cr.release_id=rm.release_id " "AND cr.dataset_id='quality' WHERE rm.transform_build_id=f.build_id)" if current_release_only else '') if product_scope is not None: # Hex encodes a text literal without interpolating caller-controlled SQL. predicate += (' AND ' if predicate else ' WHERE ') + f"f.product COLLATE utf8mb4_0900_as_cs=CONVERT(0x{product_scope.encode('utf-8').hex()} USING utf8mb4) COLLATE utf8mb4_0900_as_cs" sql(f'INSERT INTO {ident(database)}.{ident(table)} SELECT f.* FROM {ident(config["mysqlDatabase"])}.{ident(table)} f{predicate};') sql(f"CREATE USER '{account}'@'127.0.0.1' IDENTIFIED BY '{password}';") user_created = True test_resources.attach_user(ROOT, database, account) sql(f"GRANT ALL PRIVILEGES ON {ident(database)}.* TO '{account}'@'127.0.0.1';") jar = max((ROOT / 'backend/target').glob('*.jar'), key=lambda p: p.stat().st_mtime) jar = project.backend_snapshot(jar) evidence['jarSha256'] = jar.stem env = project.environment() env.update({'MYSQL_URL': f'jdbc:mysql://127.0.0.1:{config["mysqlPort"]}/{database}?useUnicode=true&characterEncoding=utf8&serverTimezone=UTC&useSSL=false&allowPublicKeyRetrieval=true', 'MYSQL_USER': account, 'MYSQL_PASSWORD': password, 'PORT': str(port), 'SERVER_PORT': str(port), 'QUALITY_BACKUP_DATABASE': database, 'QUALITY_ANALYSIS_RUNTIME_QUERY_PORT': str(port)}) env.update(env_overrides or {}) login_user, login_password = auth_credentials or (config['adminUsername'], config['adminPassword']) if auth_credentials is not None: env.update({'QUALITY_BOOTSTRAP_ADMIN_USERNAME': login_user, 'QUALITY_BOOTSTRAP_ADMIN_PASSWORD': login_password}) with (out / ('fresh-install-backend.log' if fresh else 'acceptance-backend.log')).open('wb') as log: os.chmod(out / ('fresh-install-backend.log' if fresh else 'acceptance-backend.log'), 0o600) process = subprocess.Popen([str(project.RUNTIME / 'jdk/Contents/Home/bin/java'), '-Xms128m', '-Xmx768m', '-jar', str(jar)], cwd=ROOT, env=env, stdout=log, stderr=log, start_new_session=True) test_resources.attach_child(ROOT, database, process.pid) project.wait_http(f'http://127.0.0.1:{port}/actuator/health', seconds=90) if fresh: test_resources.seal(ROOT, database, backup.client) api = LocalApi(port, login_user, login_password) evidence['flywayVersions'] = sql('SELECT version FROM flyway_schema_history WHERE success=1 ORDER BY installed_rank;', database).splitlines() yield api, database, evidence finally: if process is not None: if process.poll() is None: os.killpg(process.pid, signal.SIGTERM) try: process.wait(timeout=30) except subprocess.TimeoutExpired: os.killpg(process.pid, signal.SIGKILL) process.wait(timeout=10) evidence['cleanup']['process'] = True if db_created: sql(f'DROP DATABASE {ident(database)};') evidence['cleanup']['database'] = True if user_created: sql(f"DROP USER '{account}'@'127.0.0.1';") evidence['cleanup']['account'] = True evidence['livePointerAfter'] = sql("SELECT release_id FROM current_release WHERE dataset_id='quality';", config['mysqlDatabase']).strip() evidence['livePointerUnchanged'] = evidence.get('livePointerBefore') == evidence['livePointerAfter'] evidence_path = out / ('fresh-install-isolation.json' if fresh else 'acceptance-isolation.json') evidence_path.write_text(json.dumps(evidence, ensure_ascii=False, indent=2) + '\n') evidence_path.chmod(0o600)