fixtureqa 0.1.0__py3-none-any.whl

fixture/api/schemas.py

@@ -0,0 +1,289 @@
+from typing import Optional
+from pydantic import BaseModel, Field
+
+
+class SessionConfigRequest(BaseModel):
+    display_name: str = ""
+    begin_string: str = "FIX.4.2"
+    sender_comp_id: str
+    target_comp_id: str
+    connection_type: str = "initiator"   # "initiator" or "acceptor"
+    host: str = "localhost"
+    port: int = Field(default=9876, ge=1, le=65535)
+    heartbeat_interval: int = Field(default=30, ge=1)
+    reconnect_interval: int = Field(default=10, ge=1)
+    data_dictionary_path: Optional[str] = None
+    use_file_log: bool = True
+    start_time: str = "00:00:00"
+    end_time: str = "00:00:00"
+    reset_on_logon: bool = True
+    reset_on_logout: bool = False
+    session_role: str = "generic"  # "client", "venue", or "generic"
+    auto_ack: bool = False
+    auto_ack_delay_ms: int = Field(default=100, ge=0)
+    auto_fill: bool = False
+    auto_fill_delay_ms: int = Field(default=500, ge=0)
+    auto_start: bool = False   # start engine immediately after adding
+
+
+class SessionResponse(BaseModel):
+    session_id: str
+    display_name: str
+    begin_string: str
+    sender_comp_id: str
+    target_comp_id: str
+    connection_type: str
+    host: str
+    port: int
+    heartbeat_interval: int
+    reconnect_interval: int
+    use_file_log: bool
+    start_time: str
+    end_time: str
+    reset_on_logon: bool
+    reset_on_logout: bool
+    session_role: str
+    auto_ack: bool
+    auto_ack_delay_ms: int
+    auto_fill: bool
+    auto_fill_delay_ms: int
+    data_dictionary_path: Optional[str]
+    status: str
+    last_sent_seq_num: int
+    last_recv_seq_num: int
+    message_count: int
+    status_changed_at: Optional[float] = None
+    last_heartbeat_at: Optional[float] = None
+    owner_username: Optional[str] = None
+
+
+class UpdateSessionRequest(BaseModel):
+    display_name: Optional[str] = None
+    begin_string: Optional[str] = None
+    sender_comp_id: Optional[str] = None
+    target_comp_id: Optional[str] = None
+    connection_type: Optional[str] = None
+    host: Optional[str] = None
+    port: Optional[int] = Field(default=None, ge=1, le=65535)
+    heartbeat_interval: Optional[int] = Field(default=None, ge=1)
+    reconnect_interval: Optional[int] = Field(default=None, ge=1)
+    data_dictionary_path: Optional[str] = None
+    use_file_log: Optional[bool] = None
+    start_time: Optional[str] = None
+    end_time: Optional[str] = None
+    session_role: Optional[str] = None
+    auto_ack: Optional[bool] = None
+    auto_ack_delay_ms: Optional[int] = Field(default=None, ge=0)
+    auto_fill: Optional[bool] = None
+    auto_fill_delay_ms: Optional[int] = Field(default=None, ge=0)
+    reset_on_logon: Optional[bool] = None
+    reset_on_logout: Optional[bool] = None
+
+
+class MessageEntryResponse(BaseModel):
+    id: Optional[int] = None   # SQLite rowid; None for in-memory entries
+    direction: str
+    admin: bool
+    seq_num: int
+    msg_type: str
+    msg_type_name: str
+    ts: str
+    fields: dict[str, str]
+    raw: str
+
+
+class SendMessageRequest(BaseModel):
+    raw: str            # raw SOH-delimited or pipe-delimited FIX string
+    no_auto_ts: bool = False  # if True, skip auto-injection of tag 60 TransactTime
+
+
+class SeqNumRequest(BaseModel):
+    sender: Optional[int] = Field(default=None, ge=1)
+    target: Optional[int] = Field(default=None, ge=1)
+
+
+class SeqNumResponse(BaseModel):
+    sender: int   # next TX seqnum
+    target: int   # next RX seqnum
+
+
+class LoginRequest(BaseModel):
+    username: str
+    password: str
+
+
+class UserResponse(BaseModel):
+    uid: str
+    username: str
+    role: str
+
+
+class TokenResponse(BaseModel):
+    access_token: str
+    token_type: str = "bearer"
+    user: UserResponse
+
+
+class SetupStatusResponse(BaseModel):
+    setup_required: bool
+
+
+class CreateAdminRequest(BaseModel):
+    username: str
+    password: str
+
+
+class UserDetailResponse(BaseModel):
+    uid: str
+    username: str
+    role: str
+    is_active: bool
+    created_at: float
+
+
+class CreateUserRequest(BaseModel):
+    username: str
+    password: str
+    role: str = "user"
+
+
+class UpdateUserRequest(BaseModel):
+    is_active: Optional[bool] = None
+    role: Optional[str] = None
+    password: Optional[str] = None
+
+
+class RegistrationStatusResponse(BaseModel):
+    enabled: bool
+    max_users: int
+    current_users: int
+
+
+class RegisterRequest(BaseModel):
+    username: str
+    password: str
+
+
+class AdminSettingsRequest(BaseModel):
+    registration_enabled: Optional[bool] = None
+    max_users: Optional[int] = None
+
+
+class HousekeepingSettingsResponse(BaseModel):
+    enabled: bool
+    msg_retention_days: int
+    log_retention_days: int
+
+
+class HousekeepingSettingsRequest(BaseModel):
+    enabled: Optional[bool] = None
+    msg_retention_days: Optional[int] = Field(default=None, ge=0)
+    log_retention_days: Optional[int] = Field(default=None, ge=0)
+
+
+class HousekeepingRunResponse(BaseModel):
+    msgs_deleted: int
+    logs_deleted: int
+
+
+class BrandingResponse(BaseModel):
+    prefix: str
+    accent: str
+    bg: str
+    bg2: str
+    bg3: str
+    border: str
+    text: str
+    text2: str
+    logo_dark: str
+    logo_light: str
+    favicon: str
+
+
+class BrandingRequest(BaseModel):
+    prefix: Optional[str] = None
+    accent: Optional[str] = None
+    bg: Optional[str] = None
+    bg2: Optional[str] = None
+    bg3: Optional[str] = None
+    border: Optional[str] = None
+    text: Optional[str] = None
+    text2: Optional[str] = None
+    logo_dark: Optional[str] = None
+    logo_light: Optional[str] = None
+    favicon: Optional[str] = None
+
+
+# FIX spec
+
+class FieldRefResponse(BaseModel):
+    tag: int
+    name: str
+    type: str
+    required: bool
+    values: dict[str, str]
+
+
+class MessageSummaryResponse(BaseModel):
+    msg_type: str
+    name: str
+    category: str
+
+
+class MessageDefResponse(BaseModel):
+    msg_type: str
+    name: str
+    category: str
+    fields: list[FieldRefResponse]
+
+
+# Templates
+
+# Scenarios
+
+class AssertionDef(BaseModel):
+    tag: str
+    op: str  # eq | ne | exists | absent
+    value: str = ""
+
+
+class ScenarioStepDef(BaseModel):
+    type: str  # send | expect | delay
+    label: str
+    template_id: Optional[str] = None
+    fields: dict[str, str] = {}
+    raw: Optional[str] = None  # pipe-or-SOH FIX string; when set, used instead of fields (supports repeating groups)
+    msg_type: Optional[str] = None
+    timeout_ms: int = 5000
+    assertions: list[AssertionDef] = []
+    delay_ms: int = 0
+
+
+class ScenarioRequest(BaseModel):
+    name: str
+    session_id: str
+    steps: list[ScenarioStepDef]
+
+
+class ScenarioResponse(BaseModel):
+    id: str
+    name: str
+    session_id: str
+    steps: list[ScenarioStepDef]
+
+
+class TemplateRequest(BaseModel):
+    name: str
+    msg_type: str
+    msg_type_name: str
+    begin_string: str
+    fields: dict[str, str]
+
+
+class TemplateResponse(BaseModel):
+    id: str
+    name: str
+    msg_type: str
+    msg_type_name: str
+    begin_string: str
+    fields: dict[str, str]

fixture/core/auth.py

@@ -0,0 +1,68 @@
+"""
+Password hashing and JWT helpers.
+
+Secret key is read from the FIXTURE_SECRET_KEY environment variable.
+If absent a random key is generated for the current process (tokens
+won't survive a restart — acceptable for dev, not for production).
+"""
+import logging
+import os
+import secrets
+
+import bcrypt as _bcrypt
+
+from jose import JWTError, jwt
+
+from .user_store import User
+
+logger = logging.getLogger(__name__)
+
+_ALGORITHM = "HS256"
+_EXPIRY_SECONDS = 8 * 60 * 60  # 8 hours
+
+_SECRET_KEY: str = os.environ.get("FIXTURE_SECRET_KEY", "")
+if not _SECRET_KEY:
+    _SECRET_KEY = secrets.token_hex(32)
+    logger.warning(
+        "FIXTURE_SECRET_KEY not set — using a random key. "
+        "Tokens will be invalidated on restart."
+    )
+
+
+def _get_secret() -> str:
+    return _SECRET_KEY
+
+
+def _encode(plain: str) -> bytes:
+    # bcrypt hard-limits at 72 bytes — truncate to avoid ValueError in bcrypt 5.x
+    return plain.encode("utf-8")[:72]
+
+
+def hash_password(plain: str) -> str:
+    return _bcrypt.hashpw(_encode(plain), _bcrypt.gensalt()).decode("utf-8")
+
+
+def verify_password(plain: str, hashed: str) -> bool:
+    try:
+        return _bcrypt.checkpw(_encode(plain), hashed.encode("utf-8"))
+    except Exception:
+        return False
+
+
+def create_token(user: User) -> str:
+    import time
+    payload = {
+        "sub": user.uid,
+        "username": user.username,
+        "role": user.role,
+        "exp": int(time.time()) + _EXPIRY_SECONDS,
+    }
+    return jwt.encode(payload, _get_secret(), algorithm=_ALGORITHM)
+
+
+def decode_token(token: str) -> dict:
+    """
+    Decode and validate a JWT. Raises jose.JWTError on invalid/expired token.
+    Returns the raw payload dict.
+    """
+    return jwt.decode(token, _get_secret(), algorithms=[_ALGORITHM])

fixture/core/config_store.py

@@ -0,0 +1,85 @@
+import json
+import os
+from typing import List
+
+from .models import SessionConfig, ConnectionType, SessionRole
+
+
+class ConfigStore:
+    """Persists session configs to per-user JSON files under data_dir/<uid>/sessions.json."""
+
+    def __init__(self, data_dir: str):
+        self._data_dir = os.path.abspath(data_dir)
+
+    def load_all(self) -> List[SessionConfig]:
+        """Scan data_dir/<uid>/sessions.json and return all sessions."""
+        configs = []
+        if not os.path.isdir(self._data_dir):
+            return configs
+        for uid in os.listdir(self._data_dir):
+            user_dir = os.path.join(self._data_dir, uid)
+            path = os.path.join(user_dir, "sessions.json")
+            if os.path.isfile(path):
+                for cfg in _load_file(path):
+                    cfg.owner_uid = uid  # authoritative from directory name
+                    configs.append(cfg)
+        return configs
+
+    def save_for_user(self, uid: str, configs: List[SessionConfig]) -> None:
+        """Atomically save one user's sessions to data_dir/<uid>/sessions.json."""
+        user_dir = os.path.join(self._data_dir, uid)
+        os.makedirs(user_dir, exist_ok=True)
+        path = os.path.join(user_dir, "sessions.json")
+        tmp = path + ".tmp"
+        with open(tmp, "w") as f:
+            json.dump([_config_to_dict(c) for c in configs], f, indent=2)
+        os.replace(tmp, path)
+
+
+def _load_file(path: str) -> List[SessionConfig]:
+    """Load a sessions.json file and return SessionConfig objects (owner_uid not set)."""
+    try:
+        with open(path) as f:
+            data = json.load(f)
+    except (OSError, json.JSONDecodeError):
+        return []
+    configs = []
+    for d in data:
+        try:
+            d["connection_type"] = ConnectionType(d["connection_type"])
+            if "session_role" in d:
+                d["session_role"] = SessionRole(d["session_role"])
+            d.pop("owner_uid", None)  # stripped — set by caller from directory name
+            configs.append(SessionConfig(**d))
+        except (KeyError, ValueError, TypeError):
+            pass  # skip malformed entries
+    return configs
+
+
+def _config_to_dict(cfg: SessionConfig) -> dict:
+    return {
+        "session_id": cfg.session_id,
+        "display_name": cfg.display_name,
+        "begin_string": cfg.begin_string,
+        "sender_comp_id": cfg.sender_comp_id,
+        "target_comp_id": cfg.target_comp_id,
+        "connection_type": cfg.connection_type.value,
+        "host": cfg.host,
+        "port": cfg.port,
+        "heartbeat_interval": cfg.heartbeat_interval,
+        "reconnect_interval": cfg.reconnect_interval,
+        "data_dictionary_path": cfg.data_dictionary_path,
+        "file_store_path": cfg.file_store_path,
+        "file_log_path": cfg.file_log_path,
+        "use_file_log": cfg.use_file_log,
+        "start_time": cfg.start_time,
+        "end_time": cfg.end_time,
+        "reset_on_logon": cfg.reset_on_logon,
+        "reset_on_logout": cfg.reset_on_logout,
+        "session_role": cfg.session_role.value,
+        "auto_ack": cfg.auto_ack,
+        "auto_ack_delay_ms": cfg.auto_ack_delay_ms,
+        "auto_fill": cfg.auto_fill,
+        "auto_fill_delay_ms": cfg.auto_fill_delay_ms,
+        # owner_uid intentionally omitted — canonical from directory name
+    }

fixture/core/events.py

@@ -0,0 +1,22 @@
+from dataclasses import dataclass, field
+from enum import Enum, auto
+from typing import Callable
+
+
+class EventType(Enum):
+    SESSION_STATUS_CHANGED = auto()
+    MESSAGE_RECEIVED = auto()
+    MESSAGE_SENT = auto()
+    ENGINE_ERROR = auto()
+
+
+@dataclass
+class SessionEvent:
+    event_type: EventType
+    session_id: str       # FIXture UUID (from SessionConfig.session_id)
+    payload: dict = field(default_factory=dict)
+    owner_uid: str = ""   # stamped by SessionManager._dispatch_event
+
+
+# Type alias for subscriber callbacks
+EventHandler = Callable[[SessionEvent], None]

fixture/core/fix_application.py

@@ -0,0 +1,67 @@
+import asyncio
+
+from fixcore.application import Application
+from fixcore.message.message import Message
+from fixcore.session.session_id import SessionID
+
+from .events import EventHandler, EventType, SessionEvent
+
+
+class FixApplication(Application):
+    """
+    One instance per logical session. Bridges fixcore callbacks
+    into the FIXture event system.
+
+    fixcore calls these methods from the asyncio event loop — no
+    thread-crossing needed. Tasks scheduled here run on the same loop
+    as FastAPI.
+    """
+
+    def __init__(self, session_id: str, event_handler: EventHandler):
+        self._session_id = session_id
+        self._event_handler = event_handler
+
+    # ------------------------------------------------------------------
+    # fixcore Application interface
+    # ------------------------------------------------------------------
+
+    def on_create(self, session_id: SessionID) -> None:
+        pass
+
+    def on_logon(self, session_id: SessionID) -> None:
+        self._emit(EventType.SESSION_STATUS_CHANGED, {"status": "LOGGED_ON"})
+
+    def on_logout(self, session_id: SessionID) -> None:
+        self._emit(EventType.SESSION_STATUS_CHANGED, {"status": "LOGGED_OUT"})
+
+    def to_admin(self, message: Message, session_id: SessionID) -> None:
+        self._emit(EventType.MESSAGE_SENT, {"raw": message.encode().decode("ascii", errors="replace"), "admin": True})
+
+    def to_app(self, message: Message, session_id: SessionID) -> None:
+        try:
+            self._emit(EventType.MESSAGE_SENT, {"raw": message.encode().decode("ascii", errors="replace"), "admin": False})
+        except Exception:
+            pass
+
+    def from_admin(self, message: Message, session_id: SessionID) -> None:
+        self._emit(EventType.MESSAGE_RECEIVED, {"raw": message.encode().decode("ascii", errors="replace"), "admin": True})
+
+    def from_app(self, message: Message, session_id: SessionID) -> None:
+        try:
+            self._emit(EventType.MESSAGE_RECEIVED, {"raw": message.encode().decode("ascii", errors="replace"), "admin": False})
+        except Exception:
+            pass
+
+    # ------------------------------------------------------------------
+    # Internal
+    # ------------------------------------------------------------------
+
+    def _emit(self, event_type: EventType, payload: dict) -> None:
+        try:
+            self._event_handler(SessionEvent(
+                event_type=event_type,
+                session_id=self._session_id,
+                payload=payload,
+            ))
+        except Exception:
+            pass

fixture/core/fix_parser.py

@@ -0,0 +1,79 @@
+"""
+Parse raw FIX strings into structured field dicts.
+
+Raw FIX uses SOH (\\x01) as the field delimiter.
+Each field is "tag=value".
+"""
+
+from .fix_tags import tag_name, msg_type_name
+
+SOH = "\x01"
+
+
+def parse_raw(raw: str) -> dict[int, str]:
+    """
+    Parse a raw FIX string into {tag_int: value_str}.
+    Fields that cannot be parsed are silently skipped.
+    """
+    fields: dict[int, str] = {}
+    for part in raw.split(SOH):
+        if not part:
+            continue
+        if "=" not in part:
+            continue
+        tag_str, _, value = part.partition("=")
+        try:
+            fields[int(tag_str)] = value
+        except ValueError:
+            continue
+    return fields
+
+
+def get_msg_type(fields: dict[int, str]) -> str:
+    """Return raw MsgType value (tag 35), or '' if absent."""
+    return fields.get(35, "")
+
+
+def get_seq_num(fields: dict[int, str]) -> int:
+    """Return MsgSeqNum (tag 34) as int, or 0 if absent/invalid."""
+    try:
+        return int(fields.get(34, 0))
+    except (ValueError, TypeError):
+        return 0
+
+
+def format_fields(fields: dict[int, str], use_names: bool = True) -> list[tuple[str, str]]:
+    """
+    Return a list of (label, value) pairs for display.
+    label is the tag name (if use_names) or the raw tag number.
+    Header tags (8, 9, 10, 34, 35, 49, 52, 56) are listed first.
+    """
+    HEADER_TAGS = {8, 9, 34, 35, 49, 52, 56}
+    TRAILER_TAGS = {10}
+
+    header = [(t, fields[t]) for t in sorted(HEADER_TAGS) if t in fields]
+    body = [
+        (t, fields[t])
+        for t in sorted(fields)
+        if t not in HEADER_TAGS and t not in TRAILER_TAGS
+    ]
+    trailer = [(t, fields[t]) for t in sorted(TRAILER_TAGS) if t in fields]
+
+    result = []
+    for tag, value in header + body + trailer:
+        label = tag_name(tag) if use_names else str(tag)
+        result.append((label, value))
+    return result
+
+
+def pretty_print(raw: str, use_names: bool = True) -> str:
+    """Return a multi-line human-readable representation of a raw FIX message."""
+    fields = parse_raw(raw)
+    mt = get_msg_type(fields)
+    mt_name = msg_type_name(mt) if mt else "Unknown"
+    seq = get_seq_num(fields)
+
+    lines = [f"[{mt_name}]  MsgType={mt}  SeqNum={seq}"]
+    for label, value in format_fields(fields, use_names=use_names):
+        lines.append(f"  {label} = {value}")
+    return "\n".join(lines)