465 lines
16 KiB
Python
465 lines
16 KiB
Python
#!/usr/bin/env python3
|
|
"""Render pipeline integration test.
|
|
|
|
Tests the full pipeline: STEP upload → CAD processing → thumbnail rendering →
|
|
order creation → submit → dispatch renders → wait for completed.
|
|
|
|
Usage:
|
|
# Quick smoke test (1 STEP file, 1 output type)
|
|
python scripts/test_render_pipeline.py --sample
|
|
|
|
# Full test — all output types, waits for all renders
|
|
python scripts/test_render_pipeline.py --full
|
|
|
|
# Only check render health endpoint
|
|
python scripts/test_render_pipeline.py --health
|
|
|
|
# Custom credentials / host
|
|
python scripts/test_render_pipeline.py --sample --host http://localhost:8888 \
|
|
--email admin@hartomat.com --password Admin1234!
|
|
|
|
Environment variables (alternative to flags):
|
|
TEST_HOST, TEST_EMAIL, TEST_PASSWORD
|
|
"""
|
|
import argparse
|
|
import os
|
|
import sys
|
|
import time
|
|
import json
|
|
import requests
|
|
from pathlib import Path
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Config
|
|
# ---------------------------------------------------------------------------
|
|
|
|
DEFAULT_HOST = os.environ.get("TEST_HOST", "http://localhost:8888")
|
|
DEFAULT_EMAIL = os.environ.get("TEST_EMAIL", "admin@hartomat.com")
|
|
DEFAULT_PASSWORD = os.environ.get("TEST_PASSWORD", "Admin1234!")
|
|
|
|
SAMPLE_STEP = Path(__file__).parent.parent / "step-sample-file" / "81113-l_cut.stp"
|
|
|
|
RENDER_TIMEOUT_SECONDS = 300 # 5 minutes per render
|
|
POLL_INTERVAL_SECONDS = 5
|
|
CAD_PROCESSING_TIMEOUT = 120 # 2 minutes for STEP processing
|
|
|
|
GREEN = "\033[92m"
|
|
RED = "\033[91m"
|
|
YELLOW = "\033[93m"
|
|
BLUE = "\033[94m"
|
|
RESET = "\033[0m"
|
|
|
|
passed = []
|
|
failed = []
|
|
warnings = []
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Helpers
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def ok(msg: str):
|
|
print(f" {GREEN}✓{RESET} {msg}")
|
|
passed.append(msg)
|
|
|
|
|
|
def fail(msg: str):
|
|
print(f" {RED}✗{RESET} {msg}")
|
|
failed.append(msg)
|
|
|
|
|
|
def warn(msg: str):
|
|
print(f" {YELLOW}⚠{RESET} {msg}")
|
|
warnings.append(msg)
|
|
|
|
|
|
def info(msg: str):
|
|
print(f" {BLUE}→{RESET} {msg}")
|
|
|
|
|
|
def section(title: str):
|
|
print(f"\n{BLUE}{'='*60}{RESET}")
|
|
print(f"{BLUE} {title}{RESET}")
|
|
print(f"{BLUE}{'='*60}{RESET}")
|
|
|
|
|
|
class APIClient:
|
|
def __init__(self, host: str, email: str, password: str):
|
|
self.host = host.rstrip("/")
|
|
self.session = requests.Session()
|
|
self.token: str | None = None
|
|
self._login(email, password)
|
|
|
|
def _login(self, email: str, password: str):
|
|
resp = self.session.post(
|
|
f"{self.host}/api/auth/login",
|
|
data={"username": email, "password": password},
|
|
)
|
|
resp.raise_for_status()
|
|
data = resp.json()
|
|
self.token = data["access_token"]
|
|
self.session.headers["Authorization"] = f"Bearer {self.token}"
|
|
|
|
def get(self, path: str, **kwargs) -> requests.Response:
|
|
return self.session.get(f"{self.host}/api{path}", **kwargs)
|
|
|
|
def post(self, path: str, **kwargs) -> requests.Response:
|
|
return self.session.post(f"{self.host}/api{path}", **kwargs)
|
|
|
|
def delete(self, path: str, **kwargs) -> requests.Response:
|
|
return self.session.delete(f"{self.host}/api{path}", **kwargs)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Test: Render health endpoint
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def test_health(client: APIClient) -> bool:
|
|
section("1. Render Health Check")
|
|
resp = client.get("/worker/health/render")
|
|
if resp.status_code != 200:
|
|
fail(f"GET /worker/health/render → {resp.status_code}: {resp.text[:200]}")
|
|
return False
|
|
|
|
data = resp.json()
|
|
info(f"Overall status: {data['status']}")
|
|
info(f"Render worker connected: {data['render_worker_connected']}")
|
|
info(f"Blender available: {data['blender_available']}")
|
|
info(f"asset_pipeline queue depth: {data['thumbnail_queue_depth']}")
|
|
if data.get("last_render_at"):
|
|
info(f"Last render: {data['last_render_at']} ({'success' if data['last_render_success'] else 'FAILED'}, {data['last_render_age_minutes']}m ago)")
|
|
|
|
if data["render_worker_connected"]:
|
|
ok("Render worker connected")
|
|
else:
|
|
fail("Render worker NOT connected — renders will fail")
|
|
|
|
if data["blender_available"]:
|
|
ok("Blender renderer reachable (port 8100)")
|
|
else:
|
|
fail("Blender renderer NOT reachable — thumbnail/order renders will fail")
|
|
|
|
if data["thumbnail_queue_ok"]:
|
|
ok(f"asset_pipeline queue healthy (depth={data['thumbnail_queue_depth']})")
|
|
else:
|
|
warn(f"asset_pipeline queue DEEP ({data['thumbnail_queue_depth']} tasks) — renders may be slow")
|
|
|
|
return data["status"] != "down"
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Test: STEP upload + CAD processing
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def test_step_upload(client: APIClient, step_file: Path) -> str | None:
|
|
"""Upload STEP file, wait for completed processing. Returns cad_file_id or None."""
|
|
section("2. STEP Upload + CAD Processing")
|
|
|
|
if not step_file.exists():
|
|
fail(f"Sample STEP file not found: {step_file}")
|
|
return None
|
|
|
|
info(f"Uploading {step_file.name} ({step_file.stat().st_size // 1024} KB)")
|
|
with open(step_file, "rb") as f:
|
|
resp = client.post(
|
|
"/uploads/step",
|
|
files={"file": (step_file.name, f, "application/octet-stream")},
|
|
)
|
|
|
|
if resp.status_code not in (200, 201):
|
|
fail(f"STEP upload failed: {resp.status_code} {resp.text[:300]}")
|
|
return None
|
|
|
|
data = resp.json()
|
|
cad_file_id = data["cad_file_id"]
|
|
ok(f"STEP uploaded → cad_file_id={cad_file_id[:8]}... status={data.get('status')}")
|
|
|
|
# Poll for completed processing
|
|
info(f"Waiting for CAD processing (timeout={CAD_PROCESSING_TIMEOUT}s)...")
|
|
deadline = time.time() + CAD_PROCESSING_TIMEOUT
|
|
last_status = None
|
|
while time.time() < deadline:
|
|
resp = client.get(f"/cad/{cad_file_id}")
|
|
if resp.status_code == 200:
|
|
cad = resp.json()
|
|
status = cad.get("processing_status")
|
|
if status != last_status:
|
|
info(f" CAD status: {status}")
|
|
last_status = status
|
|
if status == "completed":
|
|
ok(f"CAD processing completed (thumbnail rendered)")
|
|
return cad_file_id
|
|
if status == "failed":
|
|
fail(f"CAD processing FAILED: {cad.get('error_message', 'unknown error')}")
|
|
return None
|
|
time.sleep(POLL_INTERVAL_SECONDS)
|
|
|
|
fail(f"CAD processing timed out after {CAD_PROCESSING_TIMEOUT}s (last status: {last_status})")
|
|
return None
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Test: Order creation + submit + dispatch + wait
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def test_order_render(
|
|
client: APIClient,
|
|
cad_file_id: str,
|
|
output_type_ids: list[str],
|
|
test_label: str,
|
|
) -> bool:
|
|
"""Create a minimal order, submit, dispatch renders, wait for completion."""
|
|
section(f"3. Order Render — {test_label}")
|
|
info(f"Output types: {len(output_type_ids)}")
|
|
|
|
# Get a product that uses this CAD file
|
|
resp = client.get(f"/cad/{cad_file_id}")
|
|
if resp.status_code != 200:
|
|
fail(f"CAD file lookup failed: {resp.status_code}")
|
|
return False
|
|
|
|
# Find or create a product linked to this CAD file
|
|
product_id = None
|
|
resp_products = client.get("/products/?limit=100")
|
|
if resp_products.status_code == 200:
|
|
products = resp_products.json()
|
|
if isinstance(products, dict):
|
|
products = products.get("items", [])
|
|
for p in products:
|
|
if str(p.get("cad_file_id")) == cad_file_id:
|
|
product_id = str(p["id"])
|
|
info(f"Using existing product: {p.get('name', p['id'])[:40]}")
|
|
break
|
|
|
|
if not product_id:
|
|
# Create a minimal test product
|
|
resp_create = client.post("/products/", json={
|
|
"name": f"Test Product {cad_file_id[:8]}",
|
|
"pim_id": f"TEST-{cad_file_id[:8]}",
|
|
"is_active": True,
|
|
"cad_file_id": cad_file_id,
|
|
})
|
|
if resp_create.status_code not in (200, 201):
|
|
fail(f"Product creation failed: {resp_create.status_code} {resp_create.text[:200]}")
|
|
return False
|
|
product_id = resp_create.json()["id"]
|
|
ok(f"Created test product: {product_id[:8]}...")
|
|
|
|
# Build output_type_selections for one product
|
|
ot_selections = [{"product_id": product_id, "output_type_id": ot_id} for ot_id in output_type_ids]
|
|
|
|
# Create order via wizard endpoint
|
|
resp_order = client.post("/orders/product-order", json={
|
|
"product_id": product_id,
|
|
"output_type_selections": [
|
|
{"output_type_id": ot_id}
|
|
for ot_id in output_type_ids
|
|
],
|
|
})
|
|
if resp_order.status_code not in (200, 201):
|
|
# Fallback: try to find existing submitted order
|
|
warn(f"Product order wizard not available ({resp_order.status_code}), looking for existing order lines...")
|
|
return _test_existing_renders(client, product_id, output_type_ids)
|
|
|
|
order = resp_order.json()
|
|
order_id = order["id"]
|
|
ok(f"Order created: {order.get('order_number')} (id={order_id[:8]}...)")
|
|
|
|
return _submit_and_wait(client, order_id, output_type_ids)
|
|
|
|
|
|
def _test_existing_renders(client: APIClient, product_id: str, output_type_ids: list[str]) -> bool:
|
|
"""Find existing order lines for a product and wait for completion."""
|
|
resp = client.get(f"/orders/?limit=20")
|
|
if resp.status_code != 200:
|
|
fail("Could not list orders")
|
|
return False
|
|
orders = resp.json()
|
|
if isinstance(orders, dict):
|
|
orders = orders.get("items", [])
|
|
for order in orders:
|
|
if order.get("status") in ("submitted", "processing", "rendering"):
|
|
return _submit_and_wait(client, order["id"], output_type_ids)
|
|
warn("No suitable existing orders found for render test")
|
|
return True # non-blocking warning
|
|
|
|
|
|
def _submit_and_wait(client: APIClient, order_id: str, output_type_ids: list[str]) -> bool:
|
|
# Submit
|
|
resp_sub = client.post(f"/orders/{order_id}/submit")
|
|
if resp_sub.status_code not in (200, 201, 204):
|
|
if resp_sub.status_code == 409:
|
|
info("Order already submitted")
|
|
else:
|
|
fail(f"Order submit failed: {resp_sub.status_code} {resp_sub.text[:200]}")
|
|
return False
|
|
else:
|
|
ok("Order submitted")
|
|
|
|
# Dispatch renders
|
|
resp_disp = client.post(f"/orders/{order_id}/dispatch-renders")
|
|
if resp_disp.status_code not in (200, 201, 204):
|
|
fail(f"Dispatch renders failed: {resp_disp.status_code} {resp_disp.text[:200]}")
|
|
return False
|
|
dispatch_data = resp_disp.json() if resp_disp.content else {}
|
|
dispatched = dispatch_data.get("dispatched", "?")
|
|
ok(f"Renders dispatched ({dispatched} lines)")
|
|
|
|
# Poll for order completion
|
|
info(f"Waiting for renders to complete (timeout={RENDER_TIMEOUT_SECONDS}s per OT)...")
|
|
deadline = time.time() + RENDER_TIMEOUT_SECONDS * max(len(output_type_ids), 1)
|
|
last_summary = ""
|
|
while time.time() < deadline:
|
|
resp_ord = client.get(f"/orders/{order_id}")
|
|
if resp_ord.status_code != 200:
|
|
fail(f"Order poll failed: {resp_ord.status_code}")
|
|
return False
|
|
order = resp_ord.json()
|
|
order_status = order.get("status")
|
|
lines = order.get("lines", order.get("order_lines", []))
|
|
statuses = [l.get("render_status") for l in lines]
|
|
summary = f"order={order_status} lines={statuses}"
|
|
if summary != last_summary:
|
|
info(f" {summary}")
|
|
last_summary = summary
|
|
|
|
if order_status == "completed":
|
|
ok(f"Order completed — all {len(lines)} render(s) done")
|
|
# Check individual line results
|
|
all_success = True
|
|
for line in lines:
|
|
rs = line.get("render_status")
|
|
ot_name = line.get("output_type_name") or line.get("output_type", {}).get("name", "?")
|
|
if rs == "completed":
|
|
ok(f" Line [{ot_name}]: completed")
|
|
elif rs == "failed":
|
|
fail(f" Line [{ot_name}]: FAILED")
|
|
all_success = False
|
|
else:
|
|
warn(f" Line [{ot_name}]: {rs}")
|
|
return all_success
|
|
|
|
if order_status == "failed":
|
|
fail(f"Order FAILED — check render logs")
|
|
return False
|
|
|
|
time.sleep(POLL_INTERVAL_SECONDS)
|
|
|
|
fail(f"Render timed out after {(time.time() - deadline + RENDER_TIMEOUT_SECONDS * max(len(output_type_ids), 1)):.0f}s")
|
|
return False
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Get output types
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def get_output_types(client: APIClient) -> list[dict]:
|
|
resp = client.get("/output-types/")
|
|
if resp.status_code != 200:
|
|
resp = client.get("/output-types")
|
|
if resp.status_code != 200:
|
|
return []
|
|
data = resp.json()
|
|
if isinstance(data, dict):
|
|
data = data.get("items", [])
|
|
return [ot for ot in data if ot.get("is_active", True)]
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Main
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser(description="Render pipeline integration tests")
|
|
parser.add_argument("--host", default=DEFAULT_HOST)
|
|
parser.add_argument("--email", default=DEFAULT_EMAIL)
|
|
parser.add_argument("--password", default=DEFAULT_PASSWORD)
|
|
parser.add_argument("--health", action="store_true", help="Only run health check")
|
|
parser.add_argument("--sample", action="store_true", help="Quick sample test (1 STEP, 1 OT)")
|
|
parser.add_argument("--full", action="store_true", help="Full test (all output types)")
|
|
parser.add_argument("--step", default=str(SAMPLE_STEP), help="Path to STEP file")
|
|
args = parser.parse_args()
|
|
|
|
if not any([args.health, args.sample, args.full]):
|
|
parser.print_help()
|
|
sys.exit(0)
|
|
|
|
print(f"\n{BLUE}Render Pipeline Test{RESET}")
|
|
print(f"Host: {args.host}")
|
|
print(f"Mode: {'health' if args.health else 'sample' if args.sample else 'full'}")
|
|
|
|
# Login
|
|
try:
|
|
client = APIClient(args.host, args.email, args.password)
|
|
ok(f"Authenticated as {args.email}")
|
|
except Exception as exc:
|
|
fail(f"Authentication failed: {exc}")
|
|
sys.exit(1)
|
|
|
|
# Health check
|
|
health_ok = test_health(client)
|
|
|
|
if args.health:
|
|
_print_summary()
|
|
sys.exit(0 if not failed else 1)
|
|
|
|
if not health_ok:
|
|
warn("Health check failed — render tests may not work. Continuing anyway...")
|
|
|
|
# STEP upload
|
|
step_path = Path(args.step)
|
|
cad_file_id = test_step_upload(client, step_path)
|
|
|
|
if not cad_file_id:
|
|
fail("STEP processing failed — cannot proceed to render tests")
|
|
_print_summary()
|
|
sys.exit(1)
|
|
|
|
# Get output types
|
|
output_types = get_output_types(client)
|
|
if not output_types:
|
|
fail("No active output types found")
|
|
_print_summary()
|
|
sys.exit(1)
|
|
|
|
info(f"Found {len(output_types)} active output types: {[ot['name'] for ot in output_types]}")
|
|
|
|
if args.sample:
|
|
# Pick the first non-animation output type (fastest)
|
|
ot = next(
|
|
(ot for ot in output_types if not ot.get("is_animation") and "LQ" in ot["name"].upper()),
|
|
output_types[0],
|
|
)
|
|
info(f"Sample test using output type: {ot['name']}")
|
|
test_order_render(client, cad_file_id, [ot["id"]], f"Sample [{ot['name']}]")
|
|
|
|
elif args.full:
|
|
# Test each output type individually
|
|
for ot in output_types:
|
|
if ot.get("is_animation"):
|
|
warn(f"Skipping animation output type: {ot['name']} (too slow for full test)")
|
|
continue
|
|
test_order_render(client, cad_file_id, [ot["id"]], ot["name"])
|
|
|
|
_print_summary()
|
|
sys.exit(0 if not failed else 1)
|
|
|
|
|
|
def _print_summary():
|
|
section("Test Summary")
|
|
print(f" {GREEN}Passed:{RESET} {len(passed)}")
|
|
print(f" {RED}Failed:{RESET} {len(failed)}")
|
|
print(f" {YELLOW}Warnings:{RESET} {len(warnings)}")
|
|
if failed:
|
|
print(f"\n{RED}FAILURES:{RESET}")
|
|
for f_ in failed:
|
|
print(f" - {f_}")
|
|
if not failed:
|
|
print(f"\n{GREEN}All tests passed!{RESET}")
|
|
else:
|
|
print(f"\n{RED}Tests FAILED{RESET}")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|