fixtureqa 0.5.0__tar.gz → 0.6.0__tar.gz

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

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

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

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

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

@@ -21,6 +21,7 @@ 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}
 
@@ -29,6 +30,15 @@ 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 +274,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 +351,105 @@ 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 = {}
+        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)
+                        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"
+                                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,
+                })
+
+                idx += 1
 
-            if status == "fail":
-                if overall_status != "aborted":
-                    overall_status = "fail"
-                break
+                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 _run_send(self, step: dict, session_id: str, uid: str,
+                  counters: 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, …).
         """
         raw_field = step.get("raw", "").strip()
         if raw_field:
             from .fix_builder import build_message_from_raw
+            raw_field = value_gen.eval_field_value(raw_field, counters)
             try:
                 msg = build_message_from_raw(
                     raw_field, self._sm.get_data_dictionary(session_id), transact_time=_utc_ts())
@@ -448,7 +489,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),
+                                      value_gen.eval_field_value(str(value), counters, tag))
                     except Exception:
                         pass
 

fixtureqa-0.6.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)