Skip to content

armgit / dify

Public Imported from GitHub
0

Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.

test: use real collaboration request state (#43228)

Asuka Minato01f632d059f5
diff --git a/api/tests/unit_tests/services/test_workflow_collaboration_service.py b/api/tests/unit_tests/services/test_workflow_collaboration_service.py
index c1cbe203d63..bf02fd60eee 100644
--- a/api/tests/unit_tests/services/test_workflow_collaboration_service.py
+++ b/api/tests/unit_tests/services/test_workflow_collaboration_service.py
@@ -1,7 +1,7 @@
import logging
from collections.abc import Iterator
from contextlib import contextmanager, nullcontext
-from unittest.mock import Mock, patch
+from unittest.mock import MagicMock, Mock, patch
import pytest
from socketio.exceptions import TimeoutError as SocketIOTimeoutError
@@ -9,6 +9,7 @@ from sqlalchemy import Engine
from sqlalchemy.orm import Session
from core.rbac import RBACPermission, RBACResourceScope
+from extensions.ext_redis import RedisClientWrapper
from models.account import Account, Tenant
from models.base import TypeBase
from models.model import App, AppMode
@@ -16,6 +17,27 @@ from repositories.workflow_collaboration_repository import WorkflowCollaboration
from services.workflow_collaboration_service import SYNC_REQUEST_TIMEOUT_SECONDS, WorkflowCollaborationService
from tests.unit_tests.config_override import config_overrides_context
from tests.unit_tests.model_factories import make_app
+from tests.unit_tests.services.workflow_collaboration_fixtures import RedisState, seed_session, seed_sessions
+
+ServiceFixture = tuple[WorkflowCollaborationService, WorkflowCollaborationRepository, Mock]
+
+
+def collaboration_redis(
+ redis_transport: tuple[RedisClientWrapper, MagicMock], monkeypatch: pytest.MonkeyPatch
+) -> RedisClientWrapper:
+ client, commands = redis_transport
+ commands.side_effect = RedisState().execute
+ monkeypatch.setattr("repositories.workflow_collaboration_repository.redis_client", client)
+ return client
+
+
+def real_service(collaboration_redis: RedisClientWrapper) -> ServiceFixture:
+ assert collaboration_redis._require_client() is not None
+ repository = WorkflowCollaborationRepository()
+ socketio = Mock()
+ return WorkflowCollaborationService(repository, socketio, server_id="server-1"), repository, socketio
@pytest.fixture
@@ -49,10 +71,10 @@ class TestWorkflowCollaborationService:
return WorkflowCollaborationService(repository, socketio, server_id="server-1"), repository, socketio
def test_authorize_and_join_workflow_room_returns_leader_status(
- self, service: tuple[WorkflowCollaborationService, Mock, Mock], db_session: Session
+ self, real_service: ServiceFixture, db_session: Session
) -> None:
# Arrange
- collaboration_service, repository, socketio = service
+ collaboration_service, repository, socketio = real_service
socketio.get_session.return_value = {
"user_id": "u-1",
"username": "Jane",
@@ -82,10 +104,10 @@ class TestWorkflowCollaborationService:
resource_type=RBACResourceScope.APP,
resource_id="wf-1",
)
- repository.set_session_info.assert_called_once()
- session_info = repository.set_session_info.call_args.args[1]
+ session_info = repository.get_session_info("wf-1", "sid-1")
+ assert session_info is not None
assert session_info["server_id"] == "server-1"
- repository.refresh_server_heartbeat.assert_called_once_with("server-1")
+ assert repository.server_heartbeat_exists("server-1")
socketio.start_background_task.assert_called_once()
get_leader.assert_called_once_with("wf-1", "sid-1")
socketio.enter_room.assert_called_once_with("sid-1", "wf-1")
@@ -93,10 +115,10 @@ class TestWorkflowCollaborationService:
socketio.emit.assert_called_once_with("status", {"isLeader": True}, room="sid-1")
def test_authorize_and_join_workflow_room_returns_none_when_missing_user(
- self, service: tuple[WorkflowCollaborationService, Mock, Mock], db_session: Session
+ self, real_service: ServiceFixture, db_session: Session
) -> None:
# Arrange
- collaboration_service, _repository, socketio = service
+ collaboration_service, _repository, socketio = real_service
socketio.get_session.return_value = {}
# Act
@@ -106,22 +128,22 @@ class TestWorkflowCollaborationService:
assert result is None
def test_authorize_and_join_workflow_room_returns_none_when_missing_tenant(
- self, service: tuple[WorkflowCollaborationService, Mock, Mock], db_session: Session
+ self, real_service: ServiceFixture, db_session: Session
) -> None:
- collaboration_service, repository, socketio = service
+ collaboration_service, repository, socketio = real_service
socketio.get_session.return_value = {"user_id": "u-1", "username": "Jane", "avatar": None}
result = collaboration_service.authorize_and_join_workflow_room("wf-1", "sid-1", session=db_session)
assert result is None
- repository.set_session_info.assert_not_called()
+ assert repository.list_sessions("wf-1") == []
socketio.enter_room.assert_not_called()
socketio.emit.assert_not_called()
def test_authorize_and_join_workflow_room_returns_none_when_workflow_is_not_accessible(
- self, service: tuple[WorkflowCollaborationService, Mock, Mock], db_session: Session
+ self, real_service: ServiceFixture, db_session: Session
) -> None:
- collaboration_service, repository, socketio = service
+ collaboration_service, repository, socketio = real_service
socketio.get_session.return_value = {
"user_id": "u-1",
"username": "Jane",
@@ -149,16 +171,16 @@ class TestWorkflowCollaborationService:
resource_type=RBACResourceScope.APP,
resource_id="wf-1",
)
- repository.refresh_server_heartbeat.assert_not_called()
- repository.set_session_info.assert_not_called()
+ assert not repository.server_heartbeat_exists("server-1")
+ assert repository.list_sessions("wf-1") == []
socketio.start_background_task.assert_not_called()
get_leader.assert_not_called()
socketio.enter_room.assert_not_called()
broadcast_online_users.assert_not_called()
socketio.emit.assert_not_called()
- def test_repr_and_save_socket_identity(self, service: tuple[WorkflowCollaborationService, Mock, Mock]) -> None:
- collaboration_service, _repository, socketio = service
+ def test_repr_and_save_socket_identity(self, real_service: ServiceFixture) -> None:
+ collaboration_service, _repository, socketio = real_service
user = Account(name="Jane", email="[email protected]")
user.id = "u-1"
user.avatar = "avatar.png"
@@ -175,10 +197,8 @@ class TestWorkflowCollaborationService:
{"user_id": "u-1", "username": "Jane", "avatar": "avatar.png", "tenant_id": "t-1"},
)
- def test_can_access_workflow_uses_session(
- self, service: tuple[WorkflowCollaborationService, Mock, Mock], db_session: Session
- ) -> None:
- collaboration_service, _repository, _socketio = service
+ def test_can_access_workflow_uses_session(self, real_service: ServiceFixture, db_session: Session) -> None:
+ collaboration_service, _repository, _socketio = real_service
db_session.add_all(
[
_app(app_id="wf-1", tenant_id="tenant-1"),
@@ -201,9 +221,9 @@ class TestWorkflowCollaborationService:
)
def test_can_access_workflow_allows_maintainer_without_rbac_call(
- self, service: tuple[WorkflowCollaborationService, Mock, Mock], db_session: Session
+ self, real_service: ServiceFixture, db_session: Session
) -> None:
- collaboration_service, _repository, _socketio = service
+ collaboration_service, _repository, _socketio = real_service
db_session.add(_app(app_id="wf-1", tenant_id="tenant-1", maintainer="owner-1"))
db_session.commit()
@@ -216,12 +236,10 @@ class TestWorkflowCollaborationService:
assert result is True
check_access.assert_not_called()
- def test_relay_collaboration_event_unauthorized(
- self, service: tuple[WorkflowCollaborationService, Mock, Mock]
- ) -> None:
+ def test_relay_collaboration_event_unauthorized(self, real_service: ServiceFixture) -> None:
# Arrange
- collaboration_service, repository, _socketio = service
- repository.get_sid_mapping.return_value = None
+ collaboration_service, repository, _socketio = real_service
+ assert repository.get_sid_mapping("sid-1") is None
# Act
result = collaboration_service.relay_collaboration_event("sid-1", {})
@@ -229,12 +247,11 @@ class TestWorkflowCollaborationService:
# Assert
assert result == ({"msg": "unauthorized"}, 401)
- def test_relay_collaboration_event_emits_update(
- self, service: tuple[WorkflowCollaborationService, Mock, Mock]
- ) -> None:
+ def test_relay_collaboration_event_emits_update(self, real_service: ServiceFixture) -> None:
# Arrange
- collaboration_service, repository, socketio = service
- repository.get_sid_mapping.return_value = {"workflow_id": "wf-1", "user_id": "u-1"}
+ collaboration_service, repository, socketio = real_service
+ seed_session(repository, "sid-1")
+ repository.set_leader("wf-1", "sid-1")
payload = {"type": "mouse_move", "data": {"x": 1}, "timestamp": 123}
# Act
@@ -249,22 +266,21 @@ class TestWorkflowCollaborationService:
skip_sid="sid-1",
)
- def test_relay_collaboration_event_requires_event_type(
- self, service: tuple[WorkflowCollaborationService, Mock, Mock]
- ) -> None:
- collaboration_service, repository, _socketio = service
- repository.get_sid_mapping.return_value = {"workflow_id": "wf-1", "user_id": "u-1"}
+ def test_relay_collaboration_event_requires_event_type(self, real_service: ServiceFixture) -> None:
+ collaboration_service, repository, _socketio = real_service
+ seed_session(repository, "sid-1")
+ repository.set_leader("wf-1", "sid-1")
result = collaboration_service.relay_collaboration_event("sid-1", {"data": {"x": 1}})
assert result == ({"msg": "invalid event type"}, 400)
def test_relay_collaboration_event_graph_resync_request_forwards_to_active_leader(
- self, service: tuple[WorkflowCollaborationService, Mock, Mock]
+ self, real_service: ServiceFixture
) -> None:
- collaboration_service, repository, socketio = service
- repository.get_sid_mapping.return_value = {"workflow_id": "wf-1", "user_id": "u-1"}
- repository.get_current_leader.return_value = "sid-leader"
+ collaboration_service, repository, socketio = real_service
+ seed_session(repository, "sid-1")
+ repository.set_leader("wf-1", "sid-leader")
payload = {"type": "graph_resync_request", "data": {"reason": "reconnect"}, "timestamp": 123}
with (
@@ -284,14 +300,14 @@ class TestWorkflowCollaborationService:
},
to="sid-leader",
)
- repository.set_leader.assert_not_called()
+ assert repository.get_current_leader("wf-1") == "sid-leader"
def test_relay_collaboration_event_graph_resync_request_reelects_when_leader_is_inactive(
- self, service: tuple[WorkflowCollaborationService, Mock, Mock]
+ self, real_service: ServiceFixture
) -> None:
- collaboration_service, repository, socketio = service
- repository.get_sid_mapping.return_value = {"workflow_id": "wf-1", "user_id": "u-1"}
- repository.get_current_leader.return_value = "sid-old"
+ collaboration_service, repository, socketio = real_service
+ seed_session(repository, "sid-1")
+ repository.set_leader("wf-1", "sid-old")
payload = {"type": "graph_resync_request", "data": None, "timestamp": 123}
with (
@@ -303,9 +319,8 @@ class TestWorkflowCollaborationService:
result = collaboration_service.relay_collaboration_event("sid-1", payload)
assert result == ({"msg": "graph_resync_request_forwarded"}, 200)
- repository.delete_leader.assert_called_once_with("wf-1")
select_leader.assert_called_once_with("wf-1", preferred_sid="sid-1")
- repository.set_leader.assert_called_once_with("wf-1", "sid-1")
+ assert repository.get_current_leader("wf-1") == "sid-1"
broadcast_leader_change.assert_called_once_with("wf-1", "sid-1")
socketio.emit.assert_called_once_with(
"collaboration_update",
@@ -314,11 +329,11 @@ class TestWorkflowCollaborationService:
)
def test_relay_collaboration_event_graph_resync_request_returns_503_without_active_leader(
- self, service: tuple[WorkflowCollaborationService, Mock, Mock]
+ self, real_service: ServiceFixture
) -> None:
- collaboration_service, repository, socketio = service
- repository.get_sid_mapping.return_value = {"workflow_id": "wf-1", "user_id": "u-1"}
- repository.get_current_leader.return_value = "sid-old"
+ collaboration_service, repository, socketio = real_service
+ seed_session(repository, "sid-1")
+ repository.set_leader("wf-1", "sid-old")
payload = {"type": "graph_resync_request", "data": None, "timestamp": 123}
with (
@@ -329,8 +344,7 @@ class TestWorkflowCollaborationService:
result = collaboration_service.relay_collaboration_event("sid-1", payload)
assert result == ({"msg": "no_active_leader"}, 503)
- repository.delete_leader.assert_called_once_with("wf-1")
- repository.set_leader.assert_not_called()
+ assert repository.get_current_leader("wf-1") is None
socketio.emit.assert_not_called()
@pytest.mark.parametrize(
@@ -347,12 +361,12 @@ class TestWorkflowCollaborationService:
)
def test_relay_collaboration_event_rejects_invalid_graph_view_state(
self,
- service: tuple[WorkflowCollaborationService, Mock, Mock],
+ real_service: ServiceFixture,
graph_active: object,
sequence: object,
) -> None:
- collaboration_service, repository, _socketio = service
- repository.get_sid_mapping.return_value = {"workflow_id": "wf-1", "user_id": "u-1"}
+ collaboration_service, repository, _socketio = real_service
+ seed_session(repository, "sid-1")
payload = {
"type": "graph_view_state",
"data": {"graphActive": graph_active, "sequence": sequence},
@@ -363,13 +377,13 @@ class TestWorkflowCollaborationService:
result = collaboration_service.relay_collaboration_event("sid-1", payload)
assert result == ({"msg": "invalid graph_view_state"}, 400)
- repository.update_session_graph_active.assert_not_called()
+ session_info = repository.get_session_info("wf-1", "sid-1")
+ assert session_info is not None
+ assert "graph_active" not in session_info
- def test_relay_collaboration_event_requires_sync_request_id(
- self, service: tuple[WorkflowCollaborationService, Mock, Mock]
- ) -> None:
- collaboration_service, repository, socketio = service
- repository.get_sid_mapping.return_value = {"workflow_id": "wf-1", "user_id": "u-1"}
+ def test_relay_collaboration_event_requires_sync_request_id(self, real_service: ServiceFixture) -> None:
+ collaboration_service, repository, socketio = real_service
+ seed_session(repository, "sid-1")
with patch.object(collaboration_service, "refresh_session_state"):
result = collaboration_service.relay_collaboration_event(
@@ -380,19 +394,22 @@ class TestWorkflowCollaborationService:
socketio.call.assert_not_called()
def test_relay_collaboration_event_sync_request_forwards_to_active_leader(
- self, service: tuple[WorkflowCollaborationService, Mock, Mock]
+ self, real_service: ServiceFixture
) -> None:
- collaboration_service, repository, socketio = service
- repository.get_sid_mapping.return_value = {"workflow_id": "wf-1", "user_id": "u-1"}
- repository.get_current_leader.return_value = "sid-leader"
- repository.get_session_info.return_value = {
- "user_id": "u-2",
- "username": "B",
- "avatar": None,
- "sid": "sid-leader",
- "connected_at": 1,
- "graph_active": True,
- }
+ collaboration_service, repository, socketio = real_service
+ seed_session(repository, "sid-1")
+ repository.set_leader("wf-1", "sid-leader")
+ repository.set_session_info(
+ "wf-1",
+ {
+ "user_id": "u-2",
+ "username": "B",
+ "avatar": None,
+ "sid": "sid-leader",
+ "connected_at": 1,
+ "graph_active": True,
+ },
+ )
socketio.call.return_value = {"success": True, "hash": "hash-2", "updatedAt": 456}
payload = {
"type": "sync_request",
@@ -427,22 +444,23 @@ class TestWorkflowCollaborationService:
to="sid-leader",
timeout=SYNC_REQUEST_TIMEOUT_SECONDS,
)
- repository.set_leader.assert_not_called()
-
- def test_relay_collaboration_event_sync_request_returns_target_failure(
- self, service: tuple[WorkflowCollaborationService, Mock, Mock]
- ) -> None:
- collaboration_service, repository, socketio = service
- repository.get_sid_mapping.return_value = {"workflow_id": "wf-1", "user_id": "u-1"}
- repository.get_current_leader.return_value = "sid-leader"
- repository.get_session_info.return_value = {
- "user_id": "u-2",
- "username": "B",
- "avatar": None,
- "sid": "sid-leader",
- "connected_at": 1,
- "graph_active": True,
- }
+ assert repository.get_current_leader("wf-1") == "sid-leader"
+
+ def test_relay_collaboration_event_sync_request_returns_target_failure(self, real_service: ServiceFixture) -> None:
+ collaboration_service, repository, socketio = real_service
+ seed_session(repository, "sid-1")
+ repository.set_leader("wf-1", "sid-leader")
+ repository.set_session_info(
+ "wf-1",
+ {
+ "user_id": "u-2",
+ "username": "B",
+ "avatar": None,
+ "sid": "sid-leader",
+ "connected_at": 1,
+ "graph_active": True,
+ },
+ )
socketio.call.return_value = {"success": False, "error": "draft_workflow_not_sync"}
payload = {"type": "sync_request", "data": {"requestId": "req-1"}, "timestamp": 123}
@@ -462,20 +480,21 @@ class TestWorkflowCollaborationService:
502,
)
- def test_relay_collaboration_event_sync_request_returns_timeout(
- self, service: tuple[WorkflowCollaborationService, Mock, Mock]
- ) -> None:
- collaboration_service, repository, socketio = service
- repository.get_sid_mapping.return_value = {"workflow_id": "wf-1", "user_id": "u-1"}
- repository.get_current_leader.return_value = "sid-leader"
- repository.get_session_info.return_value = {
- "user_id": "u-2",
- "username": "B",
- "avatar": None,
- "sid": "sid-leader",
- "connected_at": 1,
- "graph_active": True,
- }
+ def test_relay_collaboration_event_sync_request_returns_timeout(self, real_service: ServiceFixture) -> None:
+ collaboration_service, repository, socketio = real_service
+ seed_session(repository, "sid-1")
+ repository.set_leader("wf-1", "sid-leader")
+ repository.set_session_info(
+ "wf-1",
+ {
+ "user_id": "u-2",
+ "username": "B",
+ "avatar": None,
+ "sid": "sid-leader",
+ "connected_at": 1,
+ "graph_active": True,
+ },
+ )
socketio.call.side_effect = SocketIOTimeoutError()
payload = {"type": "sync_request", "data": {"requestId": "req-1"}, "timestamp": 123}
@@ -497,19 +516,22 @@ class TestWorkflowCollaborationService:
],
)
def test_relay_collaboration_event_sync_request_rejects_invalid_target_response(
- self, service: tuple[WorkflowCollaborationService, Mock, Mock], target_result: object
+ self, real_service: ServiceFixture, target_result: object
) -> None:
- collaboration_service, repository, socketio = service
- repository.get_sid_mapping.return_value = {"workflow_id": "wf-1", "user_id": "u-1"}
- repository.get_current_leader.return_value = "sid-leader"
- repository.get_session_info.return_value = {
- "user_id": "u-2",
- "username": "B",
- "avatar": None,
- "sid": "sid-leader",
- "connected_at": 1,
- "graph_active": True,
- }
+ collaboration_service, repository, socketio = real_service
+ seed_session(repository, "sid-1")
+ repository.set_leader("wf-1", "sid-leader")
+ repository.set_session_info(
+ "wf-1",
+ {
+ "user_id": "u-2",
+ "username": "B",
+ "avatar": None,
+ "sid": "sid-leader",
+ "connected_at": 1,
+ "graph_active": True,
+ },
+ )
socketio.call.return_value = target_result
payload = {"type": "sync_request", "data": {"requestId": "req-1"}, "timestamp": 123}
@@ -522,21 +544,14 @@ class TestWorkflowCollaborationService:
assert result[1] == 502
def test_relay_collaboration_event_sync_request_reroutes_from_hidden_leader(
- self, service: tuple[WorkflowCollaborationService, Mock, Mock]
+ self, real_service: ServiceFixture
) -> None:
# Leader is connected but its tab is hidden; the visible requester takes over.
- collaboration_service, repository, socketio = service
- repository.get_sid_mapping.return_value = {"workflow_id": "wf-1", "user_id": "u-1"}
- repository.get_current_leader.return_value = "sid-leader"
- repository.get_session_info.return_value = {
- "user_id": "u-2",
- "username": "B",
- "avatar": None,
- "sid": "sid-leader",
- "connected_at": 1,
- "graph_active": False,
- }
- repository.list_sessions.return_value = [
+ collaboration_service, repository, socketio = real_service
+ seed_session(repository, "sid-1")
+ repository.set_leader("wf-1", "sid-leader")
+ repository.set_session_info(
+ "wf-1",
{
"user_id": "u-2",
"username": "B",
@@ -545,15 +560,28 @@ class TestWorkflowCollaborationService:
"connected_at": 1,
"graph_active": False,
},
- {
- "user_id": "u-1",
- "username": "A",
- "avatar": None,
- "sid": "sid-1",
- "connected_at": 2,
- "graph_active": True,
- },
- ]
+ )
+ seed_sessions(
+ repository,
+ [
+ {
+ "user_id": "u-2",
+ "username": "B",
+ "avatar": None,
+ "sid": "sid-leader",
+ "connected_at": 1,
+ "graph_active": False,
+ },
+ {
+ "user_id": "u-1",
+ "username": "A",
+ "avatar": None,
+ "sid": "sid-1",
+ "connected_at": 2,
+ "graph_active": True,
+ },
+ ],
+ )
socketio.call.return_value = {"success": True, "hash": "hash-2", "updatedAt": 456}
payload = {
"type": "sync_request",
@@ -570,7 +598,7 @@ class TestWorkflowCollaborationService:
assert result[1] == 200
assert result[0]["success"] is True
- repository.set_leader.assert_called_once_with("wf-1", "sid-1")
+ assert repository.get_current_leader("wf-1") == "sid-1"
broadcast_leader_change.assert_called_once_with("wf-1", "sid-1")
socketio.call.assert_called_once_with(
"collaboration_update",
@@ -585,21 +613,14 @@ class TestWorkflowCollaborationService:
)
def test_relay_collaboration_event_sync_request_all_hidden_falls_back_to_requester(
- self, service: tuple[WorkflowCollaborationService, Mock, Mock]
+ self, real_service: ServiceFixture
) -> None:
# Every tab hidden: the requester still becomes leader so the save is not dropped.
- collaboration_service, repository, socketio = service
- repository.get_sid_mapping.return_value = {"workflow_id": "wf-1", "user_id": "u-1"}
- repository.get_current_leader.return_value = "sid-leader"
- repository.get_session_info.return_value = {
- "user_id": "u-2",
- "username": "B",
- "avatar": None,
- "sid": "sid-leader",
- "connected_at": 1,
- "graph_active": False,
- }
- repository.list_sessions.return_value = [
+ collaboration_service, repository, socketio = real_service
+ seed_session(repository, "sid-1")
+ repository.set_leader("wf-1", "sid-leader")
+ repository.set_session_info(
+ "wf-1",
{
"user_id": "u-2",
"username": "B",
@@ -608,15 +629,28 @@ class TestWorkflowCollaborationService:
"connected_at": 1,
"graph_active": False,
},
- {
- "user_id": "u-1",
- "username": "A",
- "avatar": None,
- "sid": "sid-1",
- "connected_at": 2,
- "graph_active": False,
- },
- ]
+ )
+ seed_sessions(
+ repository,
+ [
+ {
+ "user_id": "u-2",
+ "username": "B",
+ "avatar": None,
+ "sid": "sid-leader",
+ "connected_at": 1,
+ "graph_active": False,
+ },
+ {
+ "user_id": "u-1",
+ "username": "A",
+ "avatar": None,
+ "sid": "sid-1",
+ "connected_at": 2,
+ "graph_active": False,
+ },
+ ],
+ )
socketio.call.return_value = {"success": True, "hash": "hash-2", "updatedAt": 456}
payload = {
"type": "sync_request",
@@ -633,7 +667,7 @@ class TestWorkflowCollaborationService:
assert result[1] == 200
assert result[0]["success"] is True
- repository.set_leader.assert_called_once_with("wf-1", "sid-1")
+ assert repository.get_current_leader("wf-1") == "sid-1"
broadcast_leader_change.assert_called_once_with("wf-1", "sid-1")
socketio.call.assert_called_once_with(
"collaboration_update",
diff --git a/api/tests/unit_tests/services/workflow_collaboration_fixtures.py b/api/tests/unit_tests/services/workflow_collaboration_fixtures.py
new file mode 100644
index 00000000000..3f52c719d09
--- /dev/null
+++ b/api/tests/unit_tests/services/workflow_collaboration_fixtures.py
@@ -0,0 +1,82 @@
+"""Stateful Redis command transport for collaboration service tests."""
+
+from collections.abc import Sequence
+
+from repositories.workflow_collaboration_repository import WorkflowCollaborationRepository, WorkflowSessionInfo
+
+
+class RedisState:
+ """Store strings and hashes; reject commands this test transport does not implement."""
+
+ def __init__(self) -> None:
+ self.values: dict[bytes, bytes] = {}
+ self.hashes: dict[bytes, dict[bytes, bytes]] = {}
+ self.expirations: dict[bytes, int] = {}
+
+ @staticmethod
+ def _bytes(value: object) -> bytes:
+ return value if isinstance(value, bytes) else str(value).encode()
+
+ def execute(self, command: str, *args: object, **_kwargs: object) -> object:
+ key = self._bytes(args[0])
+ match command:
+ case "GET":
+ return self.values.get(key)
+ case "SET" | "SETEX":
+ if "NX" in args and key in self.values:
+ return None
+ self.values[key] = self._bytes(args[2] if command == "SETEX" else args[1])
+ if command == "SETEX":
+ self.expirations[key] = int(str(args[1]))
+ elif "EX" in args:
+ self.expirations[key] = int(str(args[args.index("EX") + 1]))
+ return True
+ case "EXISTS":
+ return int(key in self.values or bool(self.hashes.get(key)))
+ case "EXPIRE":
+ if key not in self.values and not self.hashes.get(key):
+ return False
+ self.expirations[key] = int(str(args[1]))
+ return True
+ case "TTL":
+ return self.expirations.get(key, -1)
+ case "DEL":
+ existed = key in self.values or key in self.hashes
+ self.values.pop(key, None)
+ self.hashes.pop(key, None)
+ self.expirations.pop(key, None)
+ return int(existed)
+ case "HSET":
+ fields = self.hashes.setdefault(key, {})
+ field = self._bytes(args[1])
+ added = field not in fields
+ fields[field] = self._bytes(args[2])
+ return int(added)
+ case "HGET":
+ return self.hashes.get(key, {}).get(self._bytes(args[1]))
+ case "HGETALL":
+ return self.hashes.get(key, {}).copy()
+ case "HKEYS":
+ return list(self.hashes.get(key, {}))
+ case "HEXISTS":
+ return self._bytes(args[1]) in self.hashes.get(key, {})
+ case "HDEL":
+ return int(self.hashes.get(key, {}).pop(self._bytes(args[1]), None) is not None)
+ case _:
+ raise AssertionError(f"Unexpected Redis command: {command}")
+
+
+def seed_session(
+ repository: WorkflowCollaborationRepository,
+ sid: str,
+ *,
+ user_id: str = "u-1",
+) -> None:
+ repository.set_session_info(
+ "wf-1", {"sid": sid, "user_id": user_id, "username": user_id, "avatar": None, "connected_at": 1}
+ )
+
+
+def seed_sessions(repository: WorkflowCollaborationRepository, sessions: Sequence[WorkflowSessionInfo]) -> None:
+ for session in sessions:
+ repository.set_session_info("wf-1", session)