fixtureqa 0.6.0__tar.gz → 0.7.0__tar.gz

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

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

{fixtureqa-0.6.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.6.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
@@ -25,6 +26,11 @@ 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
@@ -362,6 +368,9 @@ class ScenarioRunner:
         # 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:
@@ -392,9 +401,11 @@ class ScenarioRunner:
                 for iteration in range(step_repeat):
                     try:
                         if step_type == "send":
-                            error = self._run_send(step, session_id, uid, gen_counters)
+                            error = self._run_send(step, session_id, uid, gen_counters, last_recv)
                         elif step_type == "expect":
-                            error = self._run_expect(step, inbox, abort_flag)
+                            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():
@@ -432,8 +443,18 @@ class ScenarioRunner:
 
         return overall_status
 
+    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) -> Optional[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
@@ -445,11 +466,12 @@ class ScenarioRunner:
         {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 = value_gen.eval_field_value(raw_field, counters)
+            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())
@@ -490,7 +512,7 @@ class ScenarioRunner:
                 if tag not in SKIP_TAGS:
                     try:
                         msg.set_field(int(tag),
-                                      value_gen.eval_field_value(str(value), counters, tag))
+                                      self._resolve_value(str(value), counters, recv_fields, tag))
                     except Exception:
                         pass
 
@@ -506,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", [])
@@ -516,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:
@@ -529,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)