fixtureqa 0.6.0__tar.gz → 0.8.0__tar.gz

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

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: fixtureqa
-Version: 0.6.0
+Version: 0.8.0
 Summary: FIXture — FIX Protocol Testing Tool
 Requires-Python: >=3.10
 License-File: LICENSE
-Requires-Dist: fixcore-engine==0.6.1
+Requires-Dist: fixcore-engine==0.7.0
 Requires-Dist: fastapi>=0.111.0
 Requires-Dist: uvicorn[standard]>=0.29.0
 Requires-Dist: websockets>=12.0

{fixtureqa-0.6.0 → fixtureqa-0.8.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.8.0}/fixture/api/routers/sessions.py

@@ -54,19 +54,37 @@ def _session_response(sm: SessionManager, session_id: str, us: Optional[UserStor
         begin_string=cfg.begin_string,
         sender_comp_id=cfg.sender_comp_id,
         target_comp_id=cfg.target_comp_id,
+        session_qualifier=cfg.session_qualifier,
         connection_type=cfg.connection_type.value,
         host=cfg.host,
         port=cfg.port,
+        socket_accept_host=cfg.socket_accept_host,
         heartbeat_interval=cfg.heartbeat_interval,
         reconnect_interval=cfg.reconnect_interval,
+        logon_timeout=cfg.logon_timeout,
+        logout_timeout=cfg.logout_timeout,
+        check_latency=cfg.check_latency,
+        max_latency=cfg.max_latency,
+        requires_orig_sending_time=cfg.requires_orig_sending_time,
+        resend_request_chunk_size=cfg.resend_request_chunk_size,
+        send_redundant_resend_requests=cfg.send_redundant_resend_requests,
         use_file_log=cfg.use_file_log,
         start_time=cfg.start_time,
         end_time=cfg.end_time,
+        start_day=cfg.start_day,
+        end_day=cfg.end_day,
+        weekdays=cfg.weekdays,
+        time_zone=cfg.time_zone,
+        non_stop_session=cfg.non_stop_session,
         reset_on_logon=cfg.reset_on_logon,
         reset_on_logout=cfg.reset_on_logout,
+        reset_on_disconnect=cfg.reset_on_disconnect,
         durable_seqnums=cfg.durable_seqnums,
         log_messages=cfg.log_messages,
         validate_inbound=cfg.validate_inbound,
+        validate_fields_have_values=cfg.validate_fields_have_values,
+        validate_user_defined_fields=cfg.validate_user_defined_fields,
+        validate_fields_out_of_range=cfg.validate_fields_out_of_range,
         session_role=cfg.session_role.value,
         auto_ack=cfg.auto_ack,
         auto_ack_delay_ms=cfg.auto_ack_delay_ms,

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

@@ -7,20 +7,38 @@ class SessionConfigRequest(BaseModel):
     begin_string: str = "FIX.4.2"
     sender_comp_id: str
     target_comp_id: str
+    session_qualifier: str = ""           # SessionQualifier (disambiguate same triple)
     connection_type: str = "initiator"   # "initiator" or "acceptor"
     host: str = "localhost"
     port: int = Field(default=9876, ge=1, le=65535)
+    socket_accept_host: str = ""          # SocketAcceptHost bind addr ("" = 0.0.0.0)
     heartbeat_interval: int = Field(default=30, ge=1)
     reconnect_interval: int = Field(default=10, ge=1)
+    logon_timeout: int = Field(default=10, ge=1)
+    logout_timeout: int = Field(default=10, ge=1)
+    check_latency: bool = False           # CheckLatency: reject stale SendingTime
+    max_latency: int = Field(default=120, ge=1)   # MaxLatency (s) when check_latency
+    requires_orig_sending_time: bool = True       # RequiresOrigSendingTime
+    resend_request_chunk_size: int = Field(default=0, ge=0)  # 0 = unlimited
+    send_redundant_resend_requests: bool = False
     data_dictionary_path: Optional[str] = None
     use_file_log: bool = True
     start_time: str = "00:00:00"
     end_time: str = "00:00:00"
+    start_day: str = ""                   # StartDay/EndDay together = weekly window
+    end_day: str = ""
+    weekdays: str = ""                    # e.g. "Mon,Tue,Wed,Thu,Fri" (excl. start/end day)
+    time_zone: str = ""                   # IANA name; "" = UTC
+    non_stop_session: bool = False  # True = NonStopSession=Y (no daily seqnum reset)
     reset_on_logon: bool = False
     reset_on_logout: bool = False
+    reset_on_disconnect: bool = False
     durable_seqnums: bool = True   # False = in-memory store (no per-msg fsync; high-rate)
     log_messages: bool = True      # False = in-memory log only (no per-msg SQLite; high-rate)
     validate_inbound: bool = False # True = reject non-conforming inbound (conformant-venue mode)
+    validate_fields_have_values: bool = True       # reject "55=" (empty value)
+    validate_user_defined_fields: bool = False      # reject unknown tag>=5000
+    validate_fields_out_of_range: bool = False      # reject bad enums (e.g. Side=Z)
     session_role: str = "generic"  # "client", "venue", or "generic"
     auto_ack: bool = False
     auto_ack_delay_ms: int = Field(default=100, ge=0)
@@ -35,19 +53,37 @@ class SessionResponse(BaseModel):
     begin_string: str
     sender_comp_id: str
     target_comp_id: str
+    session_qualifier: str
     connection_type: str
     host: str
     port: int
+    socket_accept_host: str
     heartbeat_interval: int
     reconnect_interval: int
+    logon_timeout: int
+    logout_timeout: int
+    check_latency: bool
+    max_latency: int
+    requires_orig_sending_time: bool
+    resend_request_chunk_size: int
+    send_redundant_resend_requests: bool
     use_file_log: bool
     start_time: str
     end_time: str
+    start_day: str
+    end_day: str
+    weekdays: str
+    time_zone: str
+    non_stop_session: bool
     reset_on_logon: bool
     reset_on_logout: bool
+    reset_on_disconnect: bool
     durable_seqnums: bool
     log_messages: bool
     validate_inbound: bool
+    validate_fields_have_values: bool
+    validate_user_defined_fields: bool
+    validate_fields_out_of_range: bool
     session_role: str
     auto_ack: bool
     auto_ack_delay_ms: int
@@ -68,15 +104,29 @@ class UpdateSessionRequest(BaseModel):
     begin_string: Optional[str] = None
     sender_comp_id: Optional[str] = None
     target_comp_id: Optional[str] = None
+    session_qualifier: Optional[str] = None
     connection_type: Optional[str] = None
     host: Optional[str] = None
     port: Optional[int] = Field(default=None, ge=1, le=65535)
+    socket_accept_host: Optional[str] = None
     heartbeat_interval: Optional[int] = Field(default=None, ge=1)
     reconnect_interval: Optional[int] = Field(default=None, ge=1)
+    logon_timeout: Optional[int] = Field(default=None, ge=1)
+    logout_timeout: Optional[int] = Field(default=None, ge=1)
+    check_latency: Optional[bool] = None
+    max_latency: Optional[int] = Field(default=None, ge=1)
+    requires_orig_sending_time: Optional[bool] = None
+    resend_request_chunk_size: Optional[int] = Field(default=None, ge=0)
+    send_redundant_resend_requests: Optional[bool] = None
     data_dictionary_path: Optional[str] = None
     use_file_log: Optional[bool] = None
     start_time: Optional[str] = None
     end_time: Optional[str] = None
+    start_day: Optional[str] = None
+    end_day: Optional[str] = None
+    weekdays: Optional[str] = None
+    time_zone: Optional[str] = None
+    non_stop_session: Optional[bool] = None
     session_role: Optional[str] = None
     auto_ack: Optional[bool] = None
     auto_ack_delay_ms: Optional[int] = Field(default=None, ge=0)
@@ -84,9 +134,13 @@ class UpdateSessionRequest(BaseModel):
     auto_fill_delay_ms: Optional[int] = Field(default=None, ge=0)
     reset_on_logon: Optional[bool] = None
     reset_on_logout: Optional[bool] = None
+    reset_on_disconnect: Optional[bool] = None
     durable_seqnums: Optional[bool] = None
     log_messages: Optional[bool] = None
     validate_inbound: Optional[bool] = None
+    validate_fields_have_values: Optional[bool] = None
+    validate_user_defined_fields: Optional[bool] = None
+    validate_fields_out_of_range: Optional[bool] = None
 
 
 class MessageEntryResponse(BaseModel):

{fixtureqa-0.6.0 → fixtureqa-0.8.0}/fixture/core/models.py

@@ -39,12 +39,28 @@ class SessionConfig:
     sender_comp_id: str = ""
     target_comp_id: str = ""
 
+    # Disambiguates two sessions sharing the same BeginString/Sender/Target
+    # triple (fixcore SessionQualifier). "" = none.
+    session_qualifier: str = ""
+
     # Connection
     connection_type: ConnectionType = ConnectionType.INITIATOR
     host: str = "localhost"          # ignored for acceptor
     port: int = 9876
     heartbeat_interval: int = 30
     reconnect_interval: int = 10     # initiator only
+    # Acceptor bind address (fixcore SocketAcceptHost). "" = 0.0.0.0 (all
+    # interfaces). Ignored for an initiator.
+    socket_accept_host: str = ""
+
+    # Liveness timers
+    logon_timeout: int = 10          # LogonTimeout (s): wait for Logon to complete
+    logout_timeout: int = 10         # LogoutTimeout (s): wait for Logout confirmation
+    # Reject inbound messages whose SendingTime(52) skews more than max_latency
+    # seconds from the local clock (fixcore CheckLatency). Off by default
+    # (fixcore's default; QuickFIX defaults this on). PossDup resends are exempt.
+    check_latency: bool = False
+    max_latency: int = 120           # MaxLatency (s): allowed SendingTime skew when check_latency
 
     # Data dictionary (None = use bundled spec)
     data_dictionary_path: Optional[str] = None
@@ -54,13 +70,43 @@ class SessionConfig:
     file_log_path: str = "./log"
     use_file_log: bool = True
 
-    # Session schedule ("00:00:00" for both = always active)
+    # Session schedule ("00:00:00" for both = always active that day, with a
+    # daily sequence-number reset at midnight — fixcore's default daily window).
     start_time: str = "00:00:00"
     end_time: str = "00:00:00"
 
+    # Disable the daily session window entirely: when True, the engine runs as a
+    # single never-ending session (fixcore NonStopSession=Y) and never resets
+    # sequence numbers on a day boundary. False (default) keeps the daily window
+    # above, which performs the standard midnight seqnum reset. NonStopSession=Y
+    # is mutually exclusive with StartTime/EndTime, so those keys are omitted
+    # when this is set (see Session._build_settings).
+    non_stop_session: bool = False
+
+    # Extended schedule (fixcore SessionSchedule). All optional; combine with
+    # start_time/end_time. start_day+end_day => a *weekly* window (both required
+    # together). weekdays (e.g. "Mon,Tue,Wed,Thu,Fri") restricts the daily
+    # window to those days and is mutually exclusive with start_day/end_day.
+    # time_zone is an IANA name ("" = UTC). All ignored when non_stop_session.
+    start_day: str = ""
+    end_day: str = ""
+    weekdays: str = ""
+    time_zone: str = ""
+
     # Sequence number reset behaviour
     reset_on_logon: bool = False
     reset_on_logout: bool = False
+    reset_on_disconnect: bool = False   # ResetOnDisconnect: reset to 1 on every drop
+
+    # Resend / duplicate handling (fixcore)
+    # Reject a resent app message (PossDupFlag=Y) missing OrigSendingTime(122).
+    requires_orig_sending_time: bool = True
+    # Cap messages requested per outbound ResendRequest (0 = unlimited / one
+    # open-ended request); a positive value chunks recovery of a large gap.
+    resend_request_chunk_size: int = 0
+    # Re-send a ResendRequest for every out-of-order message while one is already
+    # outstanding (default N = re-request only when the gap advances).
+    send_redundant_resend_requests: bool = False
 
     # Seqnum/message store durability. True (default) = fixcore FileStore, which
     # fsyncs per message (durable resend/recovery, but caps throughput at disk
@@ -85,6 +131,18 @@ class SessionConfig:
     # on regardless of this flag.
     validate_inbound: bool = False
 
+    # Finer-grained validation, effective only while validate_inbound is on
+    # (mapped to the matching fixcore keys):
+    #   validate_fields_have_values  -> ValidateFieldsHaveValues (reject "55=")
+    #   validate_user_defined_fields -> ValidateUserDefinedFields (reject unknown tag>=5000)
+    #   validate_fields_out_of_range -> ValidateFieldsOutOfRange (reject bad enums,
+    #       e.g. Side=Z). This is the fixcore-native key; it subsumes QuickFIX/n's
+    #       inverse AllowUnknownEnumValues (=N), so that alias is not exposed
+    #       separately — leaving this off is equivalent to AllowUnknownEnumValues=Y.
+    validate_fields_have_values: bool = True
+    validate_user_defined_fields: bool = False
+    validate_fields_out_of_range: bool = False
+
     # Role / intent
     session_role: SessionRole = SessionRole.GENERIC
 

{fixtureqa-0.6.0 → fixtureqa-0.8.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)

{fixtureqa-0.6.0 → fixtureqa-0.8.0}/fixture/core/session.py

@@ -340,15 +340,49 @@ class Session:
             os.path.join(self.config.file_log_path, self.config.session_id)
         )
 
+        yn = lambda b: "Y" if b else "N"  # noqa: E731 — local boolean->FIX cfg
+
+        # Session schedule. NonStopSession=Y is mutually exclusive with *any*
+        # schedule key in fixcore (it raises on the combination), so emit either
+        # NonStopSession or the StartTime/EndTime window (+ optional refinements):
+        #   - TimeZone scopes the times/days;
+        #   - Weekdays restricts the daily window to listed days and is itself
+        #     exclusive with StartDay/EndDay, so prefer it when both are set;
+        #   - StartDay+EndDay (only together) make it a weekly window.
+        if self.config.non_stop_session:
+            schedule_lines = ["NonStopSession=Y"]
+        else:
+            schedule_lines = [
+                f"StartTime={self.config.start_time}",
+                f"EndTime={self.config.end_time}",
+            ]
+            if self.config.time_zone:
+                schedule_lines.append(f"TimeZone={self.config.time_zone}")
+            if self.config.weekdays:
+                schedule_lines.append(f"Weekdays={self.config.weekdays}")
+            elif self.config.start_day and self.config.end_day:
+                schedule_lines += [
+                    f"StartDay={self.config.start_day}",
+                    f"EndDay={self.config.end_day}",
+                ]
+
         lines = [
             "[DEFAULT]",
             f"ConnectionType={ct}",
             f"BeginString={self.config.begin_string}",
             f"SenderCompID={self.config.sender_comp_id}",
             f"TargetCompID={self.config.target_comp_id}",
+            *([f"SessionQualifier={self.config.session_qualifier}"]
+              if self.config.session_qualifier else []),
             f"HeartBtInt={self.config.heartbeat_interval}",
-            f"StartTime={self.config.start_time}",
-            f"EndTime={self.config.end_time}",
+            f"LogonTimeout={self.config.logon_timeout}",
+            f"LogoutTimeout={self.config.logout_timeout}",
+            f"CheckLatency={yn(self.config.check_latency)}",
+            f"MaxLatency={self.config.max_latency}",
+            f"RequiresOrigSendingTime={yn(self.config.requires_orig_sending_time)}",
+            f"ResendRequestChunkSize={self.config.resend_request_chunk_size}",
+            f"SendRedundantResendRequests={yn(self.config.send_redundant_resend_requests)}",
+            *schedule_lines,
             f"DataDictionary={dd_path}",
             # Always load the dictionary so inbound repeating groups decode into
             # proper instances (otherwise duplicate group-member tags collapse to
@@ -357,12 +391,17 @@ class Session:
             "UseDataDictionary=Y",
             # Permissive by default: decode group-aware but don't auto-reject
             # non-conforming inbound. Flip on per session to behave like a
-            # conformant counterparty. Requires fixcore >= 0.5.0.
-            f"ValidateIncomingMessage={'Y' if self.config.validate_inbound else 'N'}",
+            # conformant counterparty. Requires fixcore >= 0.5.0. The finer
+            # toggles below only bite while ValidateIncomingMessage=Y.
+            f"ValidateIncomingMessage={yn(self.config.validate_inbound)}",
+            f"ValidateFieldsHaveValues={yn(self.config.validate_fields_have_values)}",
+            f"ValidateUserDefinedFields={yn(self.config.validate_user_defined_fields)}",
+            f"ValidateFieldsOutOfRange={yn(self.config.validate_fields_out_of_range)}",
             f"FileStorePath={store_path}",
             f"FileLogPath={log_path}",
-            f"ResetOnLogon={'Y' if self.config.reset_on_logon else 'N'}",
-            f"ResetOnLogout={'Y' if self.config.reset_on_logout else 'N'}",
+            f"ResetOnLogon={yn(self.config.reset_on_logon)}",
+            f"ResetOnLogout={yn(self.config.reset_on_logout)}",
+            f"ResetOnDisconnect={yn(self.config.reset_on_disconnect)}",
             "",
             "[SESSION]",
         ]
@@ -375,6 +414,8 @@ class Session:
             ]
         else:
             lines.append(f"SocketAcceptPort={self.config.port}")
+            if self.config.socket_accept_host:
+                lines.append(f"SocketAcceptHost={self.config.socket_accept_host}")
 
         return SessionSettings.from_string("\n".join(lines))
 

{fixtureqa-0.6.0 → fixtureqa-0.8.0}/fixture/core/session_manager.py

@@ -264,6 +264,16 @@ class SessionManager:
             raise ValueError("target_comp_id is required")
         if config.begin_string not in ("FIX.4.2", "FIX.4.4"):
             raise ValueError(f"Unsupported FIX version: {config.begin_string!r}")
+        # Schedule-combo rules (mirror fixcore so a bad combo fails on save with a
+        # clear message instead of at engine start). Only meaningful when a
+        # windowed schedule is in play, i.e. not non-stop.
+        if not config.non_stop_session:
+            if config.weekdays and (config.start_day or config.end_day):
+                raise ValueError("Weekdays cannot be combined with StartDay/EndDay")
+            if bool(config.start_day) != bool(config.end_day):
+                raise ValueError("StartDay and EndDay must both be set (weekly window)")
+        if config.check_latency and config.max_latency < 1:
+            raise ValueError("max_latency must be >= 1 when check_latency is on")
         from .models import ConnectionType
         if config.connection_type == ConnectionType.ACCEPTOR:
             for sid, s in self._sessions.items():