fixtureqa 0.4.33__tar.gz → 0.6.0__tar.gz

{fixtureqa-0.4.33/fixtureqa.egg-info → fixtureqa-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fixtureqa
-Version: 0.4.33
+Version: 0.6.0
 Summary: FIXture — FIX Protocol Testing Tool
 Requires-Python: >=3.10
 License-File: LICENSE

{fixtureqa-0.4.33 → fixtureqa-0.6.0}/fixture/api/app.py

@@ -9,7 +9,7 @@ from fastapi.responses import FileResponse
 from ..core.custom_tag_store import CustomTagStore
 from ..core.housekeeping import HousekeepingService
 from ..core.session_manager import SessionManager
-from ..core.scenario_store import ScenarioStore
+from ..core.scenario_store import ScenarioStore, ScenarioGroupStore
 from ..core.scenario_runner import ScenarioRunner
 from ..core.spec_overlay_store import SpecOverlayStore
 from ..core.template_store import TemplateStore
@@ -86,6 +86,7 @@ def create_app(
     )
     app.state.template_store = TemplateStore(data_dir)
     app.state.scenario_store = ScenarioStore(data_dir)
+    app.state.scenario_group_store = ScenarioGroupStore(data_dir)
     app.state.custom_tag_store = CustomTagStore(data_dir)
     app.state.spec_overlay_store = SpecOverlayStore(data_dir)
     perf_writer = PerfWriter(os.path.join(data_dir, "perf.db"))

{fixtureqa-0.4.33 → fixtureqa-0.6.0}/fixture/api/deps.py

@@ -8,7 +8,7 @@ from ..core.user_store import User, UserStore
 from ..core.auth import decode_token
 from ..core.housekeeping import HousekeepingService
 from ..core.template_store import TemplateStore
-from ..core.scenario_store import ScenarioStore
+from ..core.scenario_store import ScenarioStore, ScenarioGroupStore
 from ..core.scenario_runner import ScenarioRunner
 from ..core.custom_tag_store import CustomTagStore
 from ..core.spec_overlay_store import SpecOverlayStore
@@ -88,6 +88,10 @@ def get_scenario_store(request: HTTPConnection) -> ScenarioStore:
     return request.app.state.scenario_store
 
 
+def get_scenario_group_store(request: HTTPConnection) -> ScenarioGroupStore:
+    return request.app.state.scenario_group_store
+
+
 def get_scenario_runner(request: HTTPConnection) -> ScenarioRunner:
     return request.app.state.scenario_runner
 

fixtureqa-0.6.0/fixture/api/routers/scenarios.py

@@ -0,0 +1,165 @@
+from fastapi import APIRouter, Depends, HTTPException, Response, status
+from typing import Annotated
+
+from ...core.scenario_store import ScenarioStore, ScenarioGroupStore
+from ...core.scenario_runner import ScenarioRunner
+from ...core.session_manager import SessionManager
+from ...core.user_store import User
+from ..deps import (get_current_user, get_scenario_store, get_scenario_runner,
+                    get_scenario_group_store, get_session_manager)
+from ..schemas import (ScenarioRequest, ScenarioResponse, ScenarioGroupRequest,
+                       ScenarioGroupResponse, GroupRunRequest)
+
+router = APIRouter(tags=["scenarios"])
+
+SS = Depends(get_scenario_store)
+SGS = Depends(get_scenario_group_store)
+SR = Depends(get_scenario_runner)
+SM = Depends(get_session_manager)
+CurrentUser = Depends(get_current_user)
+
+
+def _require_session_owned(sm: SessionManager, session_id: str, user: User) -> None:
+    """A scenario's session_id is stored data, not a path param — every session
+    a scenario (or group of scenarios) drives must be owned by the caller, or a
+    user could drive someone else's session through a scenario."""
+    cfg = sm.get_config(session_id)
+    if cfg is None:
+        raise HTTPException(status_code=404, detail=f"Session {session_id!r} not found")
+    if not user.is_admin and cfg.owner_uid != user.uid:
+        raise HTTPException(status_code=403, detail="Access denied")
+
+
+@router.get("", response_model=list[ScenarioResponse])
+def list_scenarios(store: ScenarioStore = SS, user: User = CurrentUser):
+    return store.list_scenarios(user.uid)
+
+
+@router.post("", response_model=ScenarioResponse, status_code=status.HTTP_201_CREATED)
+def create_scenario(body: ScenarioRequest, store: ScenarioStore = SS, user: User = CurrentUser):
+    data = body.model_dump()
+    return store.create_scenario(user.uid, data)
+
+
+@router.put("/{scenario_id}", response_model=ScenarioResponse)
+def update_scenario(
+    scenario_id: str,
+    body: ScenarioRequest,
+    store: ScenarioStore = SS,
+    user: User = CurrentUser,
+):
+    updated = store.update_scenario(user.uid, scenario_id, body.model_dump())
+    if updated is None:
+        raise HTTPException(status_code=404, detail="Scenario not found")
+    return updated
+
+
+@router.delete("/{scenario_id}", status_code=status.HTTP_204_NO_CONTENT)
+def delete_scenario(scenario_id: str, store: ScenarioStore = SS, user: User = CurrentUser):
+    if not store.delete_scenario(user.uid, scenario_id):
+        raise HTTPException(status_code=404, detail="Scenario not found")
+    return Response(status_code=status.HTTP_204_NO_CONTENT)
+
+
+# --- Suites (saved groups) + coordinated group runs -------------------------
+# Declared before the parameterised "/{scenario_id}/..." routes so that, e.g.,
+# POST "/groups/run" isn't captured by "/{scenario_id}/run".
+
+@router.get("/groups", response_model=list[ScenarioGroupResponse])
+def list_groups(store: ScenarioGroupStore = SGS, user: User = CurrentUser):
+    return store.list_groups(user.uid)
+
+
+@router.post("/groups", response_model=ScenarioGroupResponse,
+             status_code=status.HTTP_201_CREATED)
+def create_group(body: ScenarioGroupRequest, store: ScenarioGroupStore = SGS,
+                 user: User = CurrentUser):
+    return store.create_group(user.uid, body.model_dump())
+
+
+@router.put("/groups/{group_id}", response_model=ScenarioGroupResponse)
+def update_group(group_id: str, body: ScenarioGroupRequest,
+                 store: ScenarioGroupStore = SGS, user: User = CurrentUser):
+    updated = store.update_group(user.uid, group_id, body.model_dump())
+    if updated is None:
+        raise HTTPException(status_code=404, detail="Suite not found")
+    return updated
+
+
+@router.delete("/groups/{group_id}", status_code=status.HTTP_204_NO_CONTENT)
+def delete_group(group_id: str, store: ScenarioGroupStore = SGS,
+                 user: User = CurrentUser):
+    if not store.delete_group(user.uid, group_id):
+        raise HTTPException(status_code=404, detail="Suite not found")
+    return Response(status_code=status.HTTP_204_NO_CONTENT)
+
+
+def _launch_group(scenario_ids: list[str], store: ScenarioStore,
+                  runner: ScenarioRunner, sm: SessionManager, user: User) -> dict:
+    if not scenario_ids:
+        raise HTTPException(status_code=400, detail="No scenarios to run")
+    scenarios: list[dict] = []
+    for sid in scenario_ids:
+        scenario = store.get_scenario(user.uid, sid)
+        if scenario is None:
+            raise HTTPException(status_code=404, detail=f"Scenario {sid!r} not found")
+        _require_session_owned(sm, scenario.get("session_id", ""), user)
+        scenarios.append(scenario)
+    group_run_id, run_ids = runner.run_group(scenarios, user.uid)
+    return {"group_run_id": group_run_id, "run_ids": run_ids}
+
+
+@router.post("/groups/run")
+def run_group_adhoc(body: GroupRunRequest, store: ScenarioStore = SS,
+                    runner: ScenarioRunner = SR, sm: SessionManager = SM,
+                    user: User = CurrentUser):
+    """Launch an ad-hoc set of scenarios as one coordinated group."""
+    return _launch_group(body.scenario_ids, store, runner, sm, user)
+
+
+@router.post("/groups/{group_id}/run")
+def run_group_saved(group_id: str, store: ScenarioStore = SS,
+                    group_store: ScenarioGroupStore = SGS, runner: ScenarioRunner = SR,
+                    sm: SessionManager = SM, user: User = CurrentUser):
+    """Launch a saved suite as one coordinated group."""
+    group = group_store.get_group(user.uid, group_id)
+    if group is None:
+        raise HTTPException(status_code=404, detail="Suite not found")
+    return _launch_group(group.get("scenario_ids", []), store, runner, sm, user)
+
+
+@router.delete("/groups/runs/{group_run_id}", status_code=status.HTTP_204_NO_CONTENT)
+def abort_group_run(group_run_id: str, runner: ScenarioRunner = SR,
+                    user: User = CurrentUser):
+    try:
+        runner.abort_group(group_run_id, uid=user.uid, is_admin=user.is_admin)
+    except PermissionError:
+        raise HTTPException(status_code=403, detail="Access denied")
+    return Response(status_code=status.HTTP_204_NO_CONTENT)
+
+
+# --- Single scenario run ----------------------------------------------------
+
+@router.post("/{scenario_id}/run")
+def run_scenario(
+    scenario_id: str,
+    store: ScenarioStore = SS,
+    runner: ScenarioRunner = SR,
+    sm: SessionManager = SM,
+    user: User = CurrentUser,
+):
+    scenario = store.get_scenario(user.uid, scenario_id)
+    if scenario is None:
+        raise HTTPException(status_code=404, detail="Scenario not found")
+    _require_session_owned(sm, scenario.get("session_id", ""), user)
+    run_id = runner.run(scenario, user.uid)
+    return {"run_id": run_id}
+
+
+@router.delete("/runs/{run_id}", status_code=status.HTTP_204_NO_CONTENT)
+def abort_run(run_id: str, runner: ScenarioRunner = SR, user: User = CurrentUser):
+    try:
+        runner.abort(run_id, uid=user.uid, is_admin=user.is_admin)
+    except PermissionError:
+        raise HTTPException(status_code=403, detail="Access denied")
+    return Response(status_code=status.HTTP_204_NO_CONTENT)

{fixtureqa-0.4.33 → fixtureqa-0.6.0}/fixture/api/schemas.py

@@ -266,12 +266,14 @@ class ScenarioStepDef(BaseModel):
     timeout_ms: int = 5000
     assertions: list[AssertionDef] = []
     delay_ms: int = 0
+    repeat: int = 1  # run this step N times (one reported row, "(×N)")
 
 
 class ScenarioRequest(BaseModel):
     name: str
     session_id: str
     steps: list[ScenarioStepDef]
+    repeat: int = 1  # replay the whole step list N times
 
 
 class ScenarioResponse(BaseModel):
@@ -279,6 +281,23 @@ class ScenarioResponse(BaseModel):
     name: str
     session_id: str
     steps: list[ScenarioStepDef]
+    repeat: int = 1
+
+
+class ScenarioGroupRequest(BaseModel):
+    name: str
+    scenario_ids: list[str] = []
+
+
+class ScenarioGroupResponse(BaseModel):
+    id: str
+    name: str
+    scenario_ids: list[str] = []
+
+
+class GroupRunRequest(BaseModel):
+    """Ad-hoc launch of several scenarios as one coordinated group."""
+    scenario_ids: list[str]
 
 
 class TemplateRequest(BaseModel):

{fixtureqa-0.4.33 → fixtureqa-0.6.0}/fixture/core/perf_payload.py

@@ -40,12 +40,12 @@ from __future__ import annotations
 
 import random
 import re
-import string
 import uuid
 from typing import Optional
 
 from fixcore.message.message import Message
 
+from . import value_gen
 from .fix_builder import CONTROL_TAGS
 from .fix_time import utc_timestamp
 from .perf_models import RunConfig, ScenarioConfig
@@ -96,57 +96,26 @@ def _tokens(value: str) -> list[str]:
     return _TOKEN_RE.findall(value) if isinstance(value, str) else []
 
 
-# -- value generators (mirror frontend SendOptions.evalGenerator) ----------
+# -- value generators -------------------------------------------------------
+# The generator set (uuid()/seq()/random_*()/timestamp()/date()) lives in the
+# shared core.value_gen module so perf and the scenario runner evaluate field
+# values identically. Aliased here to keep the call sites below unchanged.
 
-_GEN_RE = re.compile(r"^(\w+)\(([^)]*)\)$")
-_ALNUM = string.ascii_letters + string.digits
-_GENERATOR_NAMES = {"uuid", "random_str", "random_int", "seq", "timestamp", "date"}
+_GEN_RE = value_gen.GEN_RE
+_GENERATOR_NAMES = value_gen.GENERATOR_NAMES
 _EXPIRY_UNIT_S = {"minutes": 60, "hours": 3600, "days": 86400}
 
 
 def _gen_call(name: str, raw_args: str, tag: int, counters: dict[int, int]) -> Optional[str]:
-    """Evaluate one generator call; None = unknown name / invalid args."""
-    args = [a.strip() for a in raw_args.split(",")] if raw_args.strip() else []
-    if name == "uuid":
-        return _uuid()
-    if name == "random_str":
-        n = _to_int(args[0], 8) if args else 8
-        return "".join(random.choices(_ALNUM, k=min(n, 256) if n > 0 else 8))
-    if name == "random_int":
-        try:
-            a, b = int(float(args[0])), int(float(args[1]))
-        except (IndexError, TypeError, ValueError):
-            return None
-        return str(random.randint(min(a, b), max(a, b)))
-    if name == "seq":
-        # seq() / seq(width) / seq(width, start) — incrementing counter,
-        # zero-padded to width; one counter per tag per run.
-        width = _to_int(args[0], 0) if args else 0
-        start = _to_int(args[1], 1) if len(args) > 1 else 1
-        n = counters.get(tag, start)
-        counters[tag] = n + 1
-        return str(n).zfill(width) if width > 0 else str(n)
-    if name == "timestamp":
-        return utc_timestamp()
-    if name == "date":
-        return utc_timestamp()[:8]
-    return None
+    return value_gen.gen_call(name, raw_args, tag, counters)
 
 
 def _eval_generator(value: str, tag: int, counters: dict[int, int]) -> str:
-    """Evaluate a whole-value generator expression; pass literals through."""
-    m = _GEN_RE.match(value.strip())
-    if not m:
-        return value
-    out = _gen_call(m.group(1), m.group(2), tag, counters)
-    return value if out is None else out
+    return value_gen.eval_generator(value, tag, counters)
 
 
 def _is_dynamic(value: str) -> bool:
-    """True when a template value renders differently per message
-    (contains a {token} or is a whole-value generator call)."""
-    return isinstance(value, str) and (
-        "{" in value or _GEN_RE.match(value.strip()) is not None)
+    return value_gen.is_dynamic(value)
 
 
 class PayloadFactory: