fixtureqa 0.4.33__tar.gz → 0.5.0__tar.gz

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

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

{fixtureqa-0.4.33 → fixtureqa-0.5.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.5.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.5.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.5.0}/fixture/api/schemas.py

@@ -281,6 +281,22 @@ class ScenarioResponse(BaseModel):
     steps: list[ScenarioStepDef]
 
 
+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):
     name: str
     msg_type: str

{fixtureqa-0.4.33 → fixtureqa-0.5.0}/fixture/core/scenario_runner.py

@@ -144,6 +144,14 @@ class ScenarioRunner:
         self._ts = template_store
         self._broadcast = broadcast_fn
         self._abort_flags: dict[str, tuple[str, threading.Event]] = {}  # run_id -> (owner_uid, flag)
+        # group_run_id -> {uid, run_ids, pending, statuses, started_ms}. A group
+        # is a set of single-session scenarios launched together; they coordinate
+        # purely through the FIX traffic flowing between their sessions (a venue
+        # scenario's `expect` matches the order a client scenario `send`s). The
+        # only thing the group adds over N independent runs is a *ready barrier*:
+        # every member's inbox is subscribed before any member thread can send,
+        # so the first message can never slip through before its waiter listens.
+        self._groups: dict[str, dict] = {}
         self._lock = threading.Lock()
         # The FastAPI/uvicorn event loop. Scenario steps run in worker threads
         # and must submit send coroutines back to this loop via
@@ -161,14 +169,73 @@ class ScenarioRunner:
         abort_flag = threading.Event()
         with self._lock:
             self._abort_flags[run_id] = (uid, abort_flag)
+        # Subscribe the inbox before the thread starts so a reply landing before
+        # the first expect step is buffered (see _RunInbox). The thread owns
+        # teardown (unsubscribe in _execute's finally).
+        inbox = _RunInbox(scenario.get("session_id", ""))
+        self._sm.subscribe(inbox.handler)
         t = threading.Thread(
             target=self._execute,
-            args=(scenario, uid, run_id, abort_flag),
+            args=(scenario, uid, run_id, abort_flag, inbox),
             daemon=True,
         )
         t.start()
         return run_id
 
+    def run_group(self, scenarios: list[dict], uid: str) -> tuple[str, list[str]]:
+        """Launch several scenarios concurrently as one coordinated group.
+
+        Returns (group_run_id, run_ids). Every member's inbox is subscribed here,
+        synchronously, *before* any member thread starts — that is the ready
+        barrier: a venue scenario waiting on 35=D is guaranteed to be listening
+        before a client scenario's thread can send it (emergent coordination via
+        the real FIX message flow, no explicit signalling). Ownership of each
+        scenario's session is enforced by the caller (route)."""
+        group_run_id = str(uuid.uuid4())
+        members: list[tuple[dict, str, threading.Event, _RunInbox]] = []
+        for scenario in scenarios:
+            run_id = str(uuid.uuid4())
+            abort_flag = threading.Event()
+            inbox = _RunInbox(scenario.get("session_id", ""))
+            with self._lock:
+                self._abort_flags[run_id] = (uid, abort_flag)
+            self._sm.subscribe(inbox.handler)  # barrier: listen before anyone sends
+            members.append((scenario, run_id, abort_flag, inbox))
+
+        run_ids = [m[1] for m in members]
+        with self._lock:
+            self._groups[group_run_id] = {
+                "uid": uid,
+                "run_ids": run_ids,
+                "pending": len(members),
+                "statuses": [],
+                "started_ms": _now_ms(),
+            }
+
+        self._broadcast(uid, {
+            "type": "scenario_group_start",
+            "group_run_id": group_run_id,
+            "runs": [
+                {
+                    "run_id": run_id,
+                    "scenario_id": scenario.get("id", ""),
+                    "scenario_name": scenario.get("name", ""),
+                    "session_id": scenario.get("session_id", ""),
+                    "step_count": len(scenario.get("steps", [])),
+                }
+                for scenario, run_id, _flag, _inbox in members
+            ],
+        })
+
+        for scenario, run_id, abort_flag, inbox in members:
+            t = threading.Thread(
+                target=self._execute,
+                args=(scenario, uid, run_id, abort_flag, inbox, group_run_id),
+                daemon=True,
+            )
+            t.start()
+        return group_run_id, run_ids
+
     def abort(self, run_id: str, uid: str = "", is_admin: bool = False) -> None:
         """Signal abort for a running scenario. Only the run's owner (or an
         admin) may abort it; raises PermissionError otherwise. Unknown run_ids
@@ -182,7 +249,18 @@ class ScenarioRunner:
             raise PermissionError(f"run {run_id!r} is not owned by this user")
         flag.set()
 
-    def _execute(self, scenario: dict, uid: str, run_id: str, abort_flag: threading.Event) -> None:
+    def abort_group(self, group_run_id: str, uid: str = "", is_admin: bool = False) -> None:
+        """Abort every member of a group run. Ownership is checked per member
+        (all members share the group's owner). Unknown group ids are a no-op."""
+        with self._lock:
+            group = self._groups.get(group_run_id)
+            run_ids = list(group["run_ids"]) if group else []
+        for run_id in run_ids:
+            self.abort(run_id, uid=uid, is_admin=is_admin)
+
+    def _execute(self, scenario: dict, uid: str, run_id: str,
+                 abort_flag: threading.Event, inbox: _RunInbox,
+                 group_run_id: Optional[str] = None) -> None:
         scenario_id = scenario.get("id", "")
         scenario_name = scenario.get("name", "")
         steps = scenario.get("steps", [])
@@ -193,20 +271,20 @@ class ScenarioRunner:
             "run_id": run_id,
             "scenario_id": scenario_id,
             "scenario_name": scenario_name,
+            "session_id": scenario.get("session_id", ""),
+            "group_run_id": group_run_id,
             "step_count": step_count,
         })
 
         run_start = _now_ms()
         overall_status = "pass"
 
-        # One subscription for the whole run, registered before any step
-        # executes, so replies arriving between steps are buffered for the
-        # next expect instead of being missed.
-        inbox = _RunInbox(scenario.get("session_id", ""))
-        self._sm.subscribe(inbox.handler)
+        # The inbox is already subscribed (by run/run_group, before this thread
+        # started) so replies arriving before/between steps are buffered for the
+        # next expect instead of being missed. This thread owns teardown.
         try:
             overall_status = self._run_steps(scenario, uid, run_id, abort_flag,
-                                             steps, inbox, overall_status)
+                                             steps, inbox, overall_status, group_run_id)
         finally:
             self._sm.unsubscribe(inbox.handler)
 
@@ -218,6 +296,7 @@ class ScenarioRunner:
         self._broadcast(uid, {
             "type": "scenario_complete",
             "run_id": run_id,
+            "group_run_id": group_run_id,
             "status": overall_status,
             "duration_ms": total_ms,
         })
@@ -225,9 +304,41 @@ class ScenarioRunner:
         with self._lock:
             self._abort_flags.pop(run_id, None)
 
+        if group_run_id is not None:
+            self._on_child_complete(group_run_id, uid, overall_status)
+
+    def _on_child_complete(self, group_run_id: str, uid: str, status: str) -> None:
+        """Record a member's terminal status; when the last member finishes,
+        broadcast the aggregate group result (fail > aborted > pass)."""
+        with self._lock:
+            group = self._groups.get(group_run_id)
+            if group is None:
+                return
+            group["statuses"].append(status)
+            group["pending"] -= 1
+            if group["pending"] > 0:
+                return
+            statuses = group["statuses"]
+            started_ms = group["started_ms"]
+            del self._groups[group_run_id]
+
+        if "fail" in statuses:
+            agg = "fail"
+        elif "aborted" in statuses:
+            agg = "aborted"
+        else:
+            agg = "pass"
+
+        self._broadcast(uid, {
+            "type": "scenario_group_complete",
+            "group_run_id": group_run_id,
+            "status": agg,
+            "duration_ms": int(_now_ms() - started_ms),
+        })
+
     def _run_steps(self, scenario: dict, uid: str, run_id: str,
                    abort_flag: threading.Event, steps: list, inbox: _RunInbox,
-                   overall_status: str) -> str:
+                   overall_status: str, group_run_id: Optional[str] = None) -> str:
         for idx, step in enumerate(steps):
             if abort_flag.is_set():
                 overall_status = "aborted"
@@ -239,6 +350,7 @@ class ScenarioRunner:
             self._broadcast(uid, {
                 "type": "scenario_step",
                 "run_id": run_id,
+                "group_run_id": group_run_id,
                 "step_index": idx,
                 "label": label,
                 "status": "running",
@@ -272,6 +384,7 @@ class ScenarioRunner:
             self._broadcast(uid, {
                 "type": "scenario_step",
                 "run_id": run_id,
+                "group_run_id": group_run_id,
                 "step_index": idx,
                 "label": label,
                 "status": status,

{fixtureqa-0.4.33 → fixtureqa-0.5.0}/fixture/core/scenario_store.py

@@ -34,3 +34,30 @@ class ScenarioStore(JsonListStore):
 
     def delete_scenario(self, uid: str, scenario_id: str) -> bool:
         return self.delete_item(uid, scenario_id)
+
+
+class ScenarioGroupStore(JsonListStore):
+    """A suite = a named, saved grouping of scenario ids launched together as
+    one coordinated run (data/<uid>/scenario_groups.json)."""
+
+    def __init__(self, data_dir: str):
+        super().__init__()
+        self._data_dir = os.path.abspath(data_dir)
+
+    def _file(self, uid: str) -> str:
+        return os.path.join(self._data_dir, uid, "scenario_groups.json")
+
+    def list_groups(self, uid: str) -> list[dict]:
+        return self.list_items(uid)
+
+    def get_group(self, uid: str, group_id: str) -> Optional[dict]:
+        return self.get_item(uid, group_id)
+
+    def create_group(self, uid: str, data: dict) -> dict:
+        return self.create_item(uid, data)
+
+    def update_group(self, uid: str, group_id: str, data: dict) -> Optional[dict]:
+        return self.update_item(uid, group_id, data)
+
+    def delete_group(self, uid: str, group_id: str) -> bool:
+        return self.delete_item(uid, group_id)