fixtureqa 0.14.0__tar.gz → 0.15.0__tar.gz

{fixtureqa-0.14.0/fixtureqa.egg-info → fixtureqa-0.15.0}/PKG-INFO

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

{fixtureqa-0.14.0 → fixtureqa-0.15.0}/fixture/api/connection_manager.py

@@ -263,11 +263,12 @@ class ConnectionManager:
         self._prune([ws for ws, ok in zip(targets, oks) if not ok])
 
     async def _broadcast(self, session_id: str, payload: dict, owner_uid: str) -> None:
-        # A connection receives the event if it is an admin, or its uid
-        # matches the session owner.
-        targets = [ws for ws, info in {**self._clients.get(session_id, {}),
-                                       **self._clients.get("*", {})}.items()
-                   if info.is_admin or info.uid == owner_uid]
+        # FIX sessions are visible to every user, so session events (status +
+        # message frames) go to all connections subscribed to this session's
+        # room or the global "*" room. `owner_uid` is retained for the call
+        # signature but no longer filters delivery.
+        targets = list({**self._clients.get(session_id, {}),
+                        **self._clients.get("*", {})}.keys())
         await self._fan_out(targets, payload)
 
     async def _broadcast_to_user(self, uid: str, data: dict) -> None:

{fixtureqa-0.14.0 → fixtureqa-0.15.0}/fixture/api/deps.py

@@ -66,8 +66,10 @@ def get_owned_session(
     user: User = Depends(get_current_user),
 ):
     """Resolve the `session_id` path param to its SessionConfig, enforcing
-    that the caller owns it (or is admin). One dependency instead of a
-    _check_ownership copy in every session-scoped router."""
+    that the caller owns it (or is admin). Use this for CONTROL actions
+    (start/stop, edit, delete, clear, seqnums). Viewing and sending are open to
+    every user via get_viewable_session — sessions are visible (and sendable) to
+    all."""
     sm: SessionManager = request.app.state.session_manager
     cfg = sm.get_config(session_id)
     if cfg is None:
@@ -77,6 +79,22 @@ def get_owned_session(
     return cfg
 
 
+def get_viewable_session(
+    session_id: str,
+    request: HTTPConnection,
+    _user: User = Depends(get_current_user),
+):
+    """Resolve the `session_id` path param to its SessionConfig for READ access.
+    Every authenticated user may view any session (FIX sessions are globally
+    visible); the only gate is that the session exists. Control actions still go
+    through get_owned_session for owner/admin enforcement."""
+    sm: SessionManager = request.app.state.session_manager
+    cfg = sm.get_config(session_id)
+    if cfg is None:
+        raise HTTPException(status_code=404, detail="Session not found")
+    return cfg
+
+
 def get_housekeeping(request: HTTPConnection) -> HousekeepingService:
     return request.app.state.housekeeping
 

{fixtureqa-0.14.0 → fixtureqa-0.15.0}/fixture/api/routers/messages.py

@@ -9,13 +9,14 @@ from ...core.models import SessionConfig
 from ...core.session_manager import SessionManager
 from ...core.user_store import User, UserStore
 from ..schemas import MessageEntryResponse
-from ..deps import get_session_manager, get_owned_session, get_user_store
+from ..deps import get_session_manager, get_owned_session, get_viewable_session, get_user_store
 
 router = APIRouter(tags=["messages"])
 
 SM = Annotated[SessionManager, Depends(get_session_manager)]
 US = Annotated[UserStore, Depends(get_user_store)]
 OwnedSession = Annotated[SessionConfig, Depends(get_owned_session)]
+ViewableSession = Annotated[SessionConfig, Depends(get_viewable_session)]
 
 
 def _username_map(entries, users: UserStore) -> dict[str, str]:
@@ -48,7 +49,7 @@ def _to_response(e, usernames: dict[str, str]) -> MessageEntryResponse:
 @router.get("/{session_id}/messages", response_model=list[MessageEntryResponse])
 def get_messages(
     session_id: str,
-    _cfg: OwnedSession,
+    _cfg: ViewableSession,
     sm: SM,
     users: US,
     direction: Optional[str] = Query(default=None, description="IN or OUT"),
@@ -81,7 +82,7 @@ def get_messages(
 @router.get("/{session_id}/messages/search", response_model=list[MessageEntryResponse])
 def search_messages(
     session_id: str,
-    _cfg: OwnedSession,
+    _cfg: ViewableSession,
     sm: SM,
     users: US,
     q: str = Query(..., min_length=1, description="substring or regex query over raw FIX"),
@@ -106,7 +107,7 @@ def search_messages(
 @router.get("/{session_id}/messages/export")
 def export_messages(
     session_id: str,
-    _cfg: OwnedSession,
+    _cfg: ViewableSession,
     sm: SM,
     users: US,
     fmt: str = Query(default="csv", description="Export format: csv or fix"),

{fixtureqa-0.14.0 → fixtureqa-0.15.0}/fixture/api/routers/sessions.py

@@ -7,7 +7,7 @@ from ...core.models import SessionConfig, ConnectionType, SessionRole
 from ...core.user_store import User, UserStore
 from ...core.spec_store import SpecStore
 from ..schemas import SessionConfigRequest, SessionResponse, UpdateSessionRequest, SendMessageRequest, SeqNumRequest, SeqNumResponse
-from ..deps import get_session_manager, get_current_user, get_owned_session, get_user_store, get_spec_store
+from ..deps import get_session_manager, get_current_user, get_owned_session, get_viewable_session, get_user_store, get_spec_store
 
 router = APIRouter(tags=["sessions"])
 
@@ -16,6 +16,7 @@ US = Annotated[UserStore, Depends(get_user_store)]
 SS = Annotated[SpecStore, Depends(get_spec_store)]
 CurrentUser = Annotated[User, Depends(get_current_user)]
 OwnedSession = Annotated[SessionConfig, Depends(get_owned_session)]
+ViewableSession = Annotated[SessionConfig, Depends(get_viewable_session)]
 
 def _bundled_specs() -> set[str]:
     """Bundled spec names fixcore resolves by itself — transport dictionaries
@@ -126,8 +127,10 @@ def _session_response(sm: SessionManager, session_id: str, us: Optional[UserStor
 
 
 def _owner_store(us: UserStore, user: User) -> Optional[UserStore]:
-    """Only admin responses carry owner_username (the UI owner badge / Mine filter)."""
-    return us if user.is_admin else None
+    """Every response carries owner_username: sessions are visible to all users,
+    so the UI owner badge / "Mine" filter needs the owner on every session,
+    not just for admins."""
+    return us
 
 
 @router.get("/", response_model=list[SessionResponse])
@@ -190,7 +193,7 @@ def import_sessions(body: list[SessionConfigRequest], sm: SM, us: US, ss: SS, us
 
 
 @router.get("/{session_id}", response_model=SessionResponse)
-def get_session(session_id: str, _cfg: OwnedSession, sm: SM, us: US, user: CurrentUser):
+def get_session(session_id: str, _cfg: ViewableSession, sm: SM, us: US, user: CurrentUser):
     return _session_response(sm, session_id, _owner_store(us, user))
 
 
@@ -240,8 +243,10 @@ async def stop_session(
 
 
 @router.post("/{session_id}/send")
-async def send_message(session_id: str, body: SendMessageRequest, _cfg: OwnedSession,
+async def send_message(session_id: str, body: SendMessageRequest, _cfg: ViewableSession,
                        sm: SM, user: CurrentUser):
+    # Sending is open to any user who can view the session (not just the owner);
+    # each message is still attributed to the actual sender via user_id below.
     from ...core.fix_builder import build_message_from_raw
     from ...core.fix_time import utc_timestamp
 

{fixtureqa-0.14.0 → fixtureqa-0.15.0}/fixture/api/routers/ws.py

@@ -136,11 +136,12 @@ async def ws_single_session(
         await websocket.close(code=4003, reason="Unauthorized")
         return
 
-    # Check ownership of this specific session
+    # Sessions are visible to every authenticated user (read-only stream);
+    # the only requirement is that the session exists.
     cfg = sm.get_config(session_id)
-    if cfg is None or (not is_admin and cfg.owner_uid != uid):
-        logger.warning("WS /ws/%s: access denied for uid=%s", session_id, uid)
-        await websocket.close(code=4003, reason="Access denied")
+    if cfg is None:
+        logger.warning("WS /ws/%s: unknown session for uid=%s", session_id, uid)
+        await websocket.close(code=4004, reason="Session not found")
         return
 
     logger.info("WS /ws/%s: client connected uid=%s is_admin=%s", session_id, uid, is_admin)

{fixtureqa-0.14.0 → fixtureqa-0.15.0}/fixture/core/session_manager.py

@@ -150,11 +150,12 @@ class SessionManager:
             return [s.config for s in self._sessions.values()]
 
     def list_sessions_for_user(self, uid: str, is_admin: bool = False) -> List[SessionConfig]:
+        """All FIX sessions are visible to every authenticated user (view-only).
+        Ownership no longer filters the list — it still gates control actions
+        (start/stop/send/edit/delete) at the router layer via get_owned_session.
+        `uid`/`is_admin` are kept for call-site compatibility but unused here."""
         with self._lock:
-            configs = [s.config for s in self._sessions.values()]
-        if is_admin:
-            return configs
-        return [c for c in configs if c.owner_uid == uid]
+            return [s.config for s in self._sessions.values()]
 
     def is_running(self, session_id: str) -> bool:
         state = self.get_state(session_id)