fixtureqa 0.5.0__tar.gz → 0.7.0__tar.gz

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

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

{fixtureqa-0.5.0 → fixtureqa-0.7.0}/README.md

@@ -15,7 +15,7 @@ A Python FIX protocol testing tool. Supports FIX 4.2 and 4.4, dynamic session cr
 - **Message log** — real-time IN/OUT stream with field breakdown, filtering, cursor pagination
 - **Compose & send** — paste raw FIX or use message templates; auto-inject tag 60 and primary ID
 - **Templates** — create/edit reusable message templates with FIX spec field definitions
-- **Scenarios** — automated send/expect/delay test scripts with live pass/fail results
+- **Scenarios** — automated send/expect/delay test scripts with live pass/fail results; repeatable steps/scenarios, value generators (`uuid()`, `ORD-{seq(8)}`, …) in send values, `{recv:<tag>}` to echo an order's tags into the ack/fill that answers it, and cross-session **suites** that coordinate through real FIX traffic (e.g. a client scenario and a venue scenario run together)
 - **Venue simulation** — auto-ack and auto-fill responses for inbound NewOrderSingles
 - **Performance testing** — rate-controlled order injection with latency correlation (p50/p95/p99), live dashboard, run history and CSV export; order/exec shapes templatable per counterparty; amend (35=G) and cancel (35=F) flavours with their own reply latencies (see [PERF.md](PERF.md))
 - **Log analysis** — Overview stats, Throughput chart, Reject detail, Latency measurement (p50/p95/p99)

{fixtureqa-0.5.0 → fixtureqa-0.7.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,7 @@ class ScenarioResponse(BaseModel):
     name: str
     session_id: str
     steps: list[ScenarioStepDef]
+    repeat: int = 1
 
 
 class ScenarioGroupRequest(BaseModel):

{fixtureqa-0.5.0 → fixtureqa-0.7.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:

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

@@ -9,6 +9,7 @@ for timeout and abort signalling.
 from __future__ import annotations
 
 import asyncio
+import re
 import threading
 import time
 import uuid
@@ -21,14 +22,29 @@ from .fix_builder import _ordered_pairs
 from .fix_time import utc_timestamp
 from .session_manager import SessionManager
 from .template_store import TemplateStore
+from . import value_gen
 
 SKIP_TAGS = {8, 9, 10, 34, 35, 49, 52, 56}
 
+# {recv:<tag>} in a send value echoes that tag from the message the run's most
+# recent expect step matched (e.g. a venue ack carries the order's ClOrdID via
+# 11={recv:11}). No parens, so it never collides with value_gen's {gen(...)}.
+_RECV_RE = re.compile(r"\{recv:(\d+)\}")
+
 
 def _now_ms() -> float:
     return time.monotonic() * 1000
 
 
+def _coerce_repeat(value) -> int:
+    """Repeat counts default to and are floored at 1 — 0/negative/None/garbage
+    all become 1 so a malformed config can't silently skip a step."""
+    try:
+        return max(1, int(value))
+    except (TypeError, ValueError):
+        return 1
+
+
 def _utc_ts() -> str:
     return utc_timestamp()
 
@@ -264,7 +280,9 @@ class ScenarioRunner:
         scenario_id = scenario.get("id", "")
         scenario_name = scenario.get("name", "")
         steps = scenario.get("steps", [])
-        step_count = len(steps)
+        # Scenario-level repeat replays the whole list; each replay's steps get
+        # their own rows, so the run view expects len(steps) * repeat rows.
+        step_count = len(steps) * _coerce_repeat(scenario.get("repeat", 1))
 
         self._broadcast(uid, {
             "type": "scenario_start",
@@ -339,76 +357,121 @@ class ScenarioRunner:
     def _run_steps(self, scenario: dict, uid: str, run_id: str,
                    abort_flag: threading.Event, steps: list, inbox: _RunInbox,
                    overall_status: str, group_run_id: Optional[str] = None) -> str:
-        for idx, step in enumerate(steps):
-            if abort_flag.is_set():
-                overall_status = "aborted"
-                break
-
-            label = step.get("label", f"Step {idx + 1}")
-            step_type = step.get("type", "")
-
-            self._broadcast(uid, {
-                "type": "scenario_step",
-                "run_id": run_id,
-                "group_run_id": group_run_id,
-                "step_index": idx,
-                "label": label,
-                "status": "running",
-                "error": None,
-                "duration_ms": 0,
-            })
+        # The whole step list can run several times (scenario-level repeat); each
+        # iteration's steps get fresh, continuous step indices (so step_count =
+        # len(steps) * scenario_repeat, computed in _execute). A step can itself
+        # repeat (step-level repeat) — that stays ONE reported row labelled "(×N)",
+        # fail-fast on the first bad iteration, with its duration summed.
+        scenario_repeat = _coerce_repeat(scenario.get("repeat", 1))
+        session_id = scenario.get("session_id", "")
+        # Run-scoped seq() state so 11=ORD-{seq(4)} keeps counting across a
+        # repeated step and across scenario-level repeats (uuid()/random are
+        # always fresh regardless).
+        gen_counters: dict = {}
+        # Fields of the message the most recent expect matched, so a following
+        # send can echo them via {recv:<tag>} (FIFO: expect k matched order k).
+        last_recv: dict = {}
+        idx = 0
+        for run_iter in range(scenario_repeat):
+            for step in steps:
+                if abort_flag.is_set():
+                    return "aborted"
+
+                label = step.get("label", f"Step {idx + 1}")
+                step_type = step.get("type", "")
+                step_repeat = _coerce_repeat(step.get("repeat", 1))
+                if step_repeat > 1:
+                    label += f" (×{step_repeat})"
+                if scenario_repeat > 1:
+                    label += f" (run {run_iter + 1}/{scenario_repeat})"
+
+                self._broadcast(uid, {
+                    "type": "scenario_step",
+                    "run_id": run_id,
+                    "group_run_id": group_run_id,
+                    "step_index": idx,
+                    "label": label,
+                    "status": "running",
+                    "error": None,
+                    "duration_ms": 0,
+                })
+
+                step_start = _now_ms()
+                error: Optional[str] = None
+                for iteration in range(step_repeat):
+                    try:
+                        if step_type == "send":
+                            error = self._run_send(step, session_id, uid, gen_counters, last_recv)
+                        elif step_type == "expect":
+                            error, matched = self._run_expect(step, inbox, abort_flag)
+                            if matched is not None:
+                                last_recv = matched
+                        elif step_type == "delay":
+                            self._run_delay(step, abort_flag)
+                            if abort_flag.is_set():
+                                overall_status = "aborted"
+                                error = "Aborted"
+                    except Exception as exc:
+                        error = str(exc)
+                    if error is not None:
+                        if step_repeat > 1:
+                            error = f"iteration {iteration + 1}/{step_repeat}: {error}"
+                        break
+                    if abort_flag.is_set():
+                        break
 
-            step_start = _now_ms()
-            error: Optional[str] = None
-            status = "pass"
+                status = "fail" if error is not None else "pass"
+                duration_ms = int(_now_ms() - step_start)
 
-            try:
-                if step_type == "send":
-                    error = self._run_send(step, scenario.get("session_id", ""), uid)
-                elif step_type == "expect":
-                    error = self._run_expect(step, inbox, abort_flag)
-                elif step_type == "delay":
-                    self._run_delay(step, abort_flag)
-                    if abort_flag.is_set():
-                        overall_status = "aborted"
-                        status = "fail"
-                        error = "Aborted"
-            except Exception as exc:
-                error = str(exc)
-
-            if error is not None:
-                status = "fail"
-
-            duration_ms = int(_now_ms() - step_start)
-
-            self._broadcast(uid, {
-                "type": "scenario_step",
-                "run_id": run_id,
-                "group_run_id": group_run_id,
-                "step_index": idx,
-                "label": label,
-                "status": status,
-                "error": error,
-                "duration_ms": duration_ms,
-            })
+                self._broadcast(uid, {
+                    "type": "scenario_step",
+                    "run_id": run_id,
+                    "group_run_id": group_run_id,
+                    "step_index": idx,
+                    "label": label,
+                    "status": status,
+                    "error": error,
+                    "duration_ms": duration_ms,
+                })
 
-            if status == "fail":
-                if overall_status != "aborted":
-                    overall_status = "fail"
-                break
+                idx += 1
+
+                if status == "fail":
+                    if overall_status != "aborted":
+                        overall_status = "fail"
+                    return overall_status
 
         return overall_status
 
-    def _run_send(self, step: dict, session_id: str, uid: str) -> Optional[str]:
+    def _resolve_value(self, value: str, counters: dict, recv_fields: dict,
+                       key=0) -> str:
+        """Resolve {recv:<tag>} (echo a tag from the last matched message) then
+        the value_gen generators ({gen(...)} / whole-value). recv runs first so
+        it composes with generators (e.g. 17=EX-{recv:11}); an absent tag → ""."""
+        if isinstance(value, str) and recv_fields and "{recv:" in value:
+            value = _RECV_RE.sub(
+                lambda m: (recv_fields.get(m.group(1)) or [""])[0], value)
+        return value_gen.eval_field_value(value, counters, key)
+
+    def _run_send(self, step: dict, session_id: str, uid: str,
+                  counters: dict, recv_fields: dict) -> Optional[str]:
         """Build and send a FIX message. Returns error string or None.
 
         A 'raw' field is built group-aware via the session's DataDictionary, so
         repeating groups survive. Otherwise template + step fields merge into a
         flat dict (no repeating groups possible from a dict).
+
+        Field values may use the same generators as the Send Options UI —
+        uuid()/seq()/random_*()/timestamp()/date(), whole-value or embedded as
+        {gen(...)} — evaluated fresh per send. `counters` is the run-scoped seq()
+        state (passed in so seq() keeps incrementing across a repeated step / a
+        repeated scenario, e.g. 11=ORD-{seq(4)} → ORD-0001, ORD-0002, …).
+        `recv_fields` is the last expect's matched message, echoed via {recv:tag}.
         """
         raw_field = step.get("raw", "").strip()
         if raw_field:
             from .fix_builder import build_message_from_raw
+            raw_field = self._resolve_value(raw_field, counters, recv_fields)
             try:
                 msg = build_message_from_raw(
                     raw_field, self._sm.get_data_dictionary(session_id), transact_time=_utc_ts())
@@ -448,7 +511,8 @@ class ScenarioRunner:
             for tag, value in fields.items():
                 if tag not in SKIP_TAGS:
                     try:
-                        msg.set_field(int(tag), str(value))
+                        msg.set_field(int(tag),
+                                      self._resolve_value(str(value), counters, recv_fields, tag))
                     except Exception:
                         pass
 
@@ -464,9 +528,13 @@ class ScenarioRunner:
 
     def _run_expect(
         self, step: dict, inbox: _RunInbox, abort_flag: threading.Event
-    ) -> Optional[str]:
+    ) -> tuple[Optional[str], Optional[dict]]:
         """Consume the next inbound message matching msg_type from the run inbox
-        and evaluate the step's assertions against it. Returns error or None."""
+        and evaluate the step's assertions against it. Returns (error, fields):
+        error is None on success; fields is the matched message's multi-value
+        field dict (None on timeout/abort) so a following send can echo it via
+        {recv:<tag>}. The matched fields are returned even when an assertion
+        fails (the consumed message is still the one we looked at)."""
         expected_msg_type = step.get("msg_type", "")
         timeout_ms = step.get("timeout_ms", 5000)
         assertions: list[dict] = step.get("assertions", [])
@@ -474,10 +542,10 @@ class ScenarioRunner:
         item = inbox.next_matching(expected_msg_type, timeout_ms / 1000.0, abort_flag)
 
         if abort_flag.is_set():
-            return "Aborted"
+            return "Aborted", None
         if item is None:
             desc = expected_msg_type or "any"
-            return f"Timeout waiting for message type {desc!r} after {timeout_ms}ms"
+            return f"Timeout waiting for message type {desc!r} after {timeout_ms}ms", None
 
         fields = item["fields"]
         for assertion in assertions:
@@ -487,8 +555,8 @@ class ScenarioRunner:
                 value = assertion.get("value", "")
                 actual_list = fields.get(str(tag))
                 actual_repr = repr(actual_list[0]) if actual_list and len(actual_list) == 1 else repr(actual_list) if actual_list else "<absent>"
-                return f"Assertion failed: tag {tag} {op} {value!r} (actual: {actual_repr})"
-        return None
+                return f"Assertion failed: tag {tag} {op} {value!r} (actual: {actual_repr})", fields
+        return None, fields
 
     def _run_delay(self, step: dict, abort_flag: threading.Event) -> None:
         delay_ms = step.get("delay_ms", 0)

fixtureqa-0.7.0/fixture/core/value_gen.py

@@ -0,0 +1,100 @@
+"""Server-side value generators for outbound FIX field values.
+
+uuid() · random_str(n) · random_int(a,b) · seq(width[,start]) · timestamp() ·
+date() — mirrors the frontend SendOptions.evalFieldValue so a value typed in
+either place behaves the same. A value that is exactly one recognised call is
+replaced wholesale; generators also embed in text as {gen(...)} —
+e.g. "ORD-{seq(8)}" → "ORD-00000001". Anything else passes through unchanged.
+
+This is the single server-side implementation, shared by the perf payload
+factory (perf_payload.py) and the scenario runner (scenario_runner.py).
+
+seq() state lives in a caller-supplied `counters` dict keyed by an arbitrary
+`key` (the perf factory and scenario fields use the FIX tag, so each tag has
+its own running counter); the caller owns the dict's lifetime (one per run /
+per send).
+"""
+
+from __future__ import annotations
+
+import random
+import re
+import string
+from typing import Optional
+
+from .fix_time import utc_timestamp
+
+GENERATOR_NAMES = {"uuid", "random_str", "random_int", "seq", "timestamp", "date"}
+GEN_RE = re.compile(r"^(\w+)\(([^)]*)\)$")
+_EMBED_RE = re.compile(r"\{(\w+)\(([^)]*)\)\}")
+_ALNUM = string.ascii_letters + string.digits
+
+
+def _to_int(v, default: int = 0) -> int:
+    try:
+        return int(float(v))
+    except (TypeError, ValueError):
+        return default
+
+
+def gen_call(name: str, raw_args: str, key, counters: dict) -> Optional[str]:
+    """Evaluate one generator call; None = unknown name / invalid args."""
+    import uuid
+    args = [a.strip() for a in raw_args.split(",")] if raw_args.strip() else []
+    if name == "uuid":
+        return str(uuid.uuid4())
+    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 key.
+        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(key, start)
+        counters[key] = 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
+
+
+def eval_generator(value: str, key, counters: dict) -> 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), key, counters)
+    return value if out is None else out
+
+
+def eval_field_value(value: str, counters: dict, key=0) -> str:
+    """Whole-value generator OR generators embedded in text as {gen(...)}.
+    e.g. "uuid()" → a UUID; "ORD-{seq(8)}" → "ORD-00000001"; literals unchanged."""
+    if not isinstance(value, str):
+        return value
+    m = GEN_RE.match(value.strip())
+    if m:
+        out = gen_call(m.group(1), m.group(2), key, counters)
+        return value if out is None else out
+
+    def _sub(mm: re.Match) -> str:
+        out = gen_call(mm.group(1), mm.group(2), key, counters)
+        return mm.group(0) if out is None else out
+
+    return _EMBED_RE.sub(_sub, value)
+
+
+def is_dynamic(value: str) -> bool:
+    """True when a value renders differently per message (a {token} or a
+    whole-value generator call)."""
+    return isinstance(value, str) and (
+        "{" in value or GEN_RE.match(value.strip()) is not None)