Build and run agents you can see, understand and trust.
Python agentchatbotlarge-language-modelsllmllm-agentmcpmulti-agentmulti-modalreact-agentrealtime-agentvoice-agentvoice-assistant
# -*- coding: utf-8 -*-
# pylint: disable=protected-access
"""Unit tests for RedisStorage using fakeredis."""
from datetime import datetime as DateTime
from unittest.async_case import IsolatedAsyncioTestCase
from unittest.mock import patch
import fakeredis.aioredis
from utils import AnyString, AnyValue
from agentscope.app.storage import (
RedisStorage,
VoiceProfileData,
VoiceProfileRecord,
AgentRecord,
SessionConfig,
SessionRecord,
ChatModelConfig,
ScheduleRecord,
ScheduleData,
ChannelOrigin,
ScheduleOrigin,
TeamData,
TeamMember,
TeamRecord,
SOPAgentRef,
SOPData,
SOPRecord,
SOPRunRecord,
SOPStepDataV1,
)
from agentscope.app.storage import MCPRecord, SkillRecord
from agentscope.credential import OllamaCredential
from agentscope.mcp import HttpMCPConfig, MCPClient
from agentscope.app.storage import AgentData
from agentscope.agent import ContextConfig, ReActConfig
from agentscope.message import UserMsg, AssistantMsg, TextBlock
from agentscope.sop import SOPPhase, SOPRunState, SOPStepRunState
from agentscope.state import AgentState
def make_storage() -> RedisStorage:
"""Create a RedisStorage instance backed by fakeredis."""
storage = RedisStorage.__new__(RedisStorage)
# pylint: disable=protected-access
storage._client = fakeredis.aioredis.FakeRedis(decode_responses=True)
storage.key_ttl = None
storage.key_config = RedisStorage.KeyConfig()
return storage
def make_agent_record(user_id: str) -> AgentRecord:
"""Create a test AgentRecord with all-default sub-configs."""
return AgentRecord(
user_id=user_id,
data=AgentData(
id="agent-data-id",
name="test-agent",
system_prompt="You are a helpful assistant.",
context_config=ContextConfig(),
react_config=ReActConfig(),
),
)
def make_session_config(workspace_id: str = "ws-1") -> SessionConfig:
"""Create a test SessionConfig with a chat model config."""
return SessionConfig(
workspace_id=workspace_id,
chat_model_config=ChatModelConfig(
type="openai",
credential_id="cred-1",
model="gpt-4",
parameters={},
),
)
class TestCredential(IsolatedAsyncioTestCase):
"""Tests for credential CRUD and cascading operations."""
async def asyncSetUp(self) -> None:
"""Set up test fixtures."""
self.storage = make_storage()
self.user_id = "user-1"
async def test_create(self) -> None:
"""Create a credential and verify it is retrievable via list."""
cred_id = await self.storage.upsert_credential(
self.user_id,
OllamaCredential(host="http://localhost:11434"),
)
records = await self.storage.list_credentials(self.user_id)
self.assertEqual(len(records), 1)
self.assertEqual(records[0].id, cred_id)
self.assertEqual(records[0].data.get("type"), "ollama_credential")
self.assertEqual(
records[0].data.get("host"),
"http://localhost:11434",
)
async def test_list_empty(self) -> None:
"""Verify list returns empty when no records exist."""
records = await self.storage.list_credentials(self.user_id)
self.assertEqual(records, [])
async def test_update_in_place(self) -> None:
"""Update a credential and verify data changed without adding
a new record."""
cred_id = await self.storage.upsert_credential(
self.user_id,
OllamaCredential(host="http://old-host:11434"),
)
await self.storage.upsert_credential(
self.user_id,
OllamaCredential(id=cred_id, host="http://new-host:11434"),
)
records = await self.storage.list_credentials(self.user_id)
self.assertEqual(len(records), 1)
self.assertEqual(records[0].data.get("host"), "http://new-host:11434")
async def test_delete(self) -> None:
"""Delete a credential and verify it is gone from Redis."""
cred_id = await self.storage.upsert_credential(
self.user_id,
OllamaCredential(host="http://localhost:11434"),
)
result = await self.storage.delete_credential(self.user_id, cred_id)
self.assertTrue(result)
records = await self.storage.list_credentials(self.user_id)
self.assertEqual(records, [])
async def test_delete_nonexistent(self) -> None:
"""Verify delete returns False for non-existent record."""
result = await self.storage.delete_credential(
self.user_id,
"no-such-id",
)
self.assertFalse(result)
async def test_user_isolation(self) -> None:
"""Verify different users cannot see each other's records."""
await self.storage.upsert_credential(
"user-A",
OllamaCredential(host="http://localhost:11434"),
)
records = await self.storage.list_credentials("user-B")
self.assertEqual(records, [])
class TestAgent(IsolatedAsyncioTestCase):
"""Tests for agent CRUD and cascading operations."""
async def asyncSetUp(self) -> None:
"""Set up test fixtures."""
self.storage = make_storage()
self.user_id = "user-1"
async def test_create(self) -> None:
"""Create an agent and verify it is retrievable via list."""
record = make_agent_record(self.user_id)
agent_id = await self.storage.upsert_agent(self.user_id, record)
records = await self.storage.list_agents(self.user_id)
self.assertEqual(len(records), 1)
self.assertEqual(records[0].id, agent_id)
self.assertEqual(records[0].data.name, "test-agent")
async def test_list_empty(self) -> None:
"""Verify list returns empty when no records exist."""
records = await self.storage.list_agents(self.user_id)
self.assertEqual(records, [])
async def test_delete(self) -> None:
"""Delete an agent and verify it is gone from Redis."""
record = make_agent_record(self.user_id)
await self.storage.upsert_agent(self.user_id, record)
result = await self.storage.delete_agent(self.user_id, record.id)
self.assertTrue(result)
records = await self.storage.list_agents(self.user_id)
self.assertEqual(records, [])
async def test_delete_nonexistent(self) -> None:
"""Verify delete returns False for non-existent record."""
result = await self.storage.delete_agent(self.user_id, "no-such-id")
self.assertFalse(result)
async def test_user_isolation(self) -> None:
"""Verify different users cannot see each other's records."""
await self.storage.upsert_agent("user-A", make_agent_record("user-A"))
records = await self.storage.list_agents("user-B")
self.assertEqual(records, [])
class TestSession(IsolatedAsyncioTestCase):
"""Tests for session CRUD and cascading operations."""
async def asyncSetUp(self) -> None:
"""Set up test fixtures."""
self.storage = make_storage()
self.user_id = "user-1"
self.agent_id = "agent-1"
self.workspace_id = "ws-1"
async def test_create(self) -> None:
"""Create a session and verify it is retrievable via list."""
await self.storage.upsert_session(
self.user_id,
self.agent_id,
make_session_config(self.workspace_id),
)
records = await self.storage.list_sessions(self.user_id, self.agent_id)
self.assertEqual(len(records), 1)
self.assertEqual(records[0].config.workspace_id, self.workspace_id)
self.assertEqual(records[0].agent_id, self.agent_id)
async def test_list_empty(self) -> None:
"""Verify list returns empty when no records exist."""
records = await self.storage.list_sessions(self.user_id, self.agent_id)
self.assertEqual(records, [])
async def test_upsert_same_triple_updates_in_place(self) -> None:
"""Second upsert with the same session_id must update the existing
record, not create a second one."""
session = await self.storage.upsert_session(
self.user_id,
self.agent_id,
make_session_config(self.workspace_id),
)
first_id = session.id
await self.storage.upsert_session(
self.user_id,
self.agent_id,
make_session_config(self.workspace_id),
session_id=first_id,
)
records_after = await self.storage.list_sessions(
self.user_id,
self.agent_id,
)
self.assertEqual(len(records_after), 1)
self.assertEqual(records_after[0].id, first_id)
async def test_create_with_explicit_session_id_uses_that_key(self) -> None:
"""A caller-provided session_id should be the stored record id."""
session_id = "session-from-router"
session = await self.storage.upsert_session(
self.user_id,
self.agent_id,
make_session_config(self.workspace_id),
session_id=session_id,
)
self.assertEqual(session.id, session_id)
fetched = await self.storage.get_session(
self.user_id,
self.agent_id,
session_id,
)
self.assertIsNotNone(fetched)
self.assertEqual(fetched.id, session_id)
await self.storage.update_session_state(
self.user_id,
self.agent_id,
session_id,
AgentState(),
)
records = await self.storage.list_sessions(self.user_id, self.agent_id)
self.assertEqual([record.id for record in records], [session_id])
async def test_delete(self) -> None:
"""Delete a session and verify it is gone from Redis."""
await self.storage.upsert_session(
self.user_id,
self.agent_id,
make_session_config(self.workspace_id),
)
records = await self.storage.list_sessions(self.user_id, self.agent_id)
session_id = records[0].id
message_key = self.storage._message_key(self.user_id, session_id)
message_index_key = self.storage._message_index_key(
self.user_id,
session_id,
)
await self.storage.upsert_message(
self.user_id,
session_id,
UserMsg(name="alice", content="hello"),
)
result = await self.storage.delete_session(
self.user_id,
self.agent_id,
session_id,
)
remaining = await self.storage.list_sessions(
self.user_id,
self.agent_id,
)
self.assertDictEqual(
{
"deleted": result,
"remaining": remaining,
"message_key_count": await self.storage._client.exists(
message_key,
message_index_key,
),
},
{
"deleted": True,
"remaining": [],
"message_key_count": 0,
},
)
async def test_delete_cascades_lookup_key(self) -> None:
"""Deleting a session must remove the lookup key so a subsequent upsert
for the same (user, agent) pair creates a fresh session with a new
id."""
await self.storage.upsert_session(
self.user_id,
self.agent_id,
make_session_config(self.workspace_id),
)
records = await self.storage.list_sessions(self.user_id, self.agent_id)
old_id = records[0].id
await self.storage.delete_session(self.user_id, self.agent_id, old_id)
await self.storage.upsert_session(
self.user_id,
self.agent_id,
make_session_config(self.workspace_id),
)
new_records = await self.storage.list_sessions(
self.user_id,
self.agent_id,
)
self.assertEqual(len(new_records), 1)
self.assertNotEqual(new_records[0].id, old_id)
async def test_delete_nonexistent(self) -> None:
"""Verify delete returns False for non-existent record."""
result = await self.storage.delete_session(
self.user_id,
self.agent_id,
"no-such-id",
)
self.assertFalse(result)
async def test_agent_isolation(self) -> None:
"""Verify different agents cannot see each other's sessions."""
await self.storage.upsert_session(
self.user_id,
"agent-A",
make_session_config(self.workspace_id),
)
records = await self.storage.list_sessions(self.user_id, "agent-B")
self.assertEqual(records, [])
class TestMessage(IsolatedAsyncioTestCase):
"""Tests for message persistence: upsert_message, get_message and
list_messages."""
async def asyncSetUp(self) -> None:
"""Set up test fixtures."""
self.storage = make_storage()
self.user_id = "user-1"
self.session_id = "session-1"
async def test_upsert_appends_new_message(self) -> None:
"""Upserting a new message appends it to the session list."""
msg = UserMsg(name="alice", content="hello")
await self.storage.upsert_message(self.user_id, self.session_id, msg)
messages, has_more = await self.storage.list_messages(
self.user_id,
self.session_id,
)
self.assertFalse(has_more)
self.assertListEqual(
[m.model_dump() for m in messages],
[msg.model_dump()],
)
async def test_upsert_refreshes_message_keys_ttl(self) -> None:
"""Message list and index expire with the session storage TTL."""
self.storage.key_ttl = 60
msg = UserMsg(name="alice", content="hello")
await self.storage.upsert_message(self.user_id, self.session_id, msg)
list_ttl = await self.storage._client.ttl(
self.storage._message_key(self.user_id, self.session_id),
)
index_ttl = await self.storage._client.ttl(
self.storage._message_index_key(self.user_id, self.session_id),
)
self.assertGreater(list_ttl, 0)
self.assertGreater(index_ttl, 0)
async def test_upsert_lazily_indexes_legacy_messages(self) -> None:
"""A legacy list gains an ID index without scanning for a new ID."""
legacy = UserMsg(name="alice", content="legacy")
new = AssistantMsg(name="bot", content="new")
key = self.storage._message_key(self.user_id, self.session_id)
index_key = self.storage._message_index_key(
self.user_id,
self.session_id,
)
await self.storage._client.rpush(key, legacy.model_dump_json())
with patch.object(
self.storage,
"_find_message_index",
) as find_index:
await self.storage.upsert_message(
self.user_id,
self.session_id,
new,
)
find_index.assert_not_awaited()
messages, has_more = await self.storage.list_messages(
self.user_id,
self.session_id,
)
indexed_ids = await self.storage._client.smembers(index_key)
self.assertDictEqual(
{
"messages": [message.model_dump() for message in messages],
"has_more": has_more,
"indexed_ids": indexed_ids,
},
{
"messages": [legacy.model_dump(), new.model_dump()],
"has_more": False,
"indexed_ids": {legacy.id, new.id},
},
)
async def test_upsert_replaces_last_message_with_same_id(self) -> None:
"""Upserting a message whose id matches the last entry replaces it
in-place (streaming overwrite), rather than creating a duplicate."""
msg = AssistantMsg(name="bot", content="v1")
await self.storage.upsert_message(self.user_id, self.session_id, msg)
# Keep the same id but replace content — simulates a streaming update.
updated = msg.model_copy(
update={"content": [TextBlock(text="v2")]},
)
await self.storage.upsert_message(
self.user_id,
self.session_id,
updated,
)
messages, has_more = await self.storage.list_messages(
self.user_id,
self.session_id,
)
self.assertFalse(has_more)
self.assertListEqual(
[m.model_dump() for m in messages],
[updated.model_dump()],
"Duplicate must not be created; existing entry must be replaced.",
)
async def test_replace_refreshes_message_list_ttl(self) -> None:
"""Streaming message replacement keeps the message key expiring."""
self.storage.key_ttl = 60
msg = AssistantMsg(name="bot", content="v1")
await self.storage.upsert_message(self.user_id, self.session_id, msg)
await self.storage._client.persist(
self.storage._message_key(self.user_id, self.session_id),
)
updated = msg.model_copy(
update={"content": [TextBlock(text="v2")]},
)
await self.storage.upsert_message(
self.user_id,
self.session_id,
updated,
)
ttl = await self.storage._client.ttl(
self.storage._message_key(self.user_id, self.session_id),
)
self.assertGreater(ttl, 0)
async def test_upsert_replaces_earlier_message_with_same_id(self) -> None:
"""Upserting by id replaces a non-tail message without duplication."""
msg1 = UserMsg(name="alice", content="first")
msg2 = UserMsg(name="alice", content="second")
await self.storage.upsert_message(self.user_id, self.session_id, msg1)
await self.storage.upsert_message(self.user_id, self.session_id, msg2)
updated = msg1.model_copy(
update={"content": [TextBlock(text="updated first")]},
)
await self.storage.upsert_message(
self.user_id,
self.session_id,
updated,
)
messages, has_more = await self.storage.list_messages(
self.user_id,
self.session_id,
)
self.assertFalse(has_more)
self.assertListEqual(
[m.model_dump() for m in messages],
[updated.model_dump(), msg2.model_dump()],
)
async def test_get_message_returns_correct_message(self) -> None:
"""get_message fetches the message matching the given id."""
msg1 = UserMsg(name="alice", content="first")
msg2 = UserMsg(name="alice", content="second")
await self.storage.upsert_message(self.user_id, self.session_id, msg1)
await self.storage.upsert_message(self.user_id, self.session_id, msg2)
fetched = await self.storage.get_message(
self.user_id,
self.session_id,
msg1.id,
)
self.assertIsNotNone(fetched)
self.assertDictEqual(fetched.model_dump(), msg1.model_dump())
async def test_get_message_nonexistent_returns_none(self) -> None:
"""get_message returns None when the message id does not exist."""
result = await self.storage.get_message(
self.user_id,
self.session_id,
"no-such-id",
)
self.assertIsNone(result)
async def test_delete_message(self) -> None:
"""Deleting by id removes the matching message."""
first = UserMsg(name="alice", content="first")
second = AssistantMsg(name="bot", content="second")
updated_first = UserMsg(
id=first.id,
name="alice",
content="updated first",
)
await self.storage.upsert_message(
self.user_id,
self.session_id,
first,
)
await self.storage.upsert_message(
self.user_id,
self.session_id,
second,
)
await self.storage.upsert_message(
self.user_id,
self.session_id,
updated_first,
)
deleted = await self.storage.delete_message(
self.user_id,
self.session_id,
first.id,
)
deleted_again = await self.storage.delete_message(
self.user_id,
self.session_id,
first.id,
)
messages, has_more = await self.storage.list_messages(
self.user_id,
self.session_id,
)
indexed_ids = await self.storage._client.smembers(
self.storage._message_index_key(
self.user_id,
self.session_id,
),
)
self.assertDictEqual(
{
"deleted": deleted,
"deleted_again": deleted_again,
"messages": [message.model_dump() for message in messages],
"has_more": has_more,
"indexed_ids": indexed_ids,
},
{
"deleted": True,
"deleted_again": False,
"messages": [second.model_dump()],
"has_more": False,
"indexed_ids": {second.id},
},
)
async def test_list_messages_empty_session(self) -> None:
"""list_messages returns an empty list for a session with no
messages."""
messages, has_more = await self.storage.list_messages(
self.user_id,
self.session_id,
)
self.assertFalse(has_more)
self.assertListEqual(messages, [])
async def test_list_messages_latest_page(self) -> None:
"""list_messages without cursor returns the most recent messages."""
msgs = [UserMsg(name="alice", content=f"msg-{i}") for i in range(5)]
for m in msgs:
await self.storage.upsert_message(
self.user_id,
self.session_id,
m,
)
# Default: latest page with limit=3 → last 3 messages
page, has_more = await self.storage.list_messages(
self.user_id,
self.session_id,
limit=3,
)
self.assertTrue(has_more)
self.assertListEqual(
[m.model_dump() for m in page],
[m.model_dump() for m in msgs[2:5]],
)
async def test_list_messages_cursor_pagination(self) -> None:
"""list_messages with before cursor returns older messages."""
msgs = [UserMsg(name="alice", content=f"msg-{i}") for i in range(5)]
for m in msgs:
await self.storage.upsert_message(
self.user_id,
self.session_id,
m,
)
# Use msgs[3].id as cursor → should get msgs[0], msgs[1], msgs[2]
page, has_more = await self.storage.list_messages(
self.user_id,
self.session_id,
limit=3,
before=msgs[3].id,
)
self.assertFalse(has_more)
self.assertListEqual(
[m.model_dump() for m in page],
[m.model_dump() for m in msgs[0:3]],
)
async def test_list_messages_has_more_flag(self) -> None:
"""has_more is True when older messages exist beyond the page."""
msgs = [UserMsg(name="alice", content=f"msg-{i}") for i in range(10)]
for m in msgs:
await self.storage.upsert_message(
self.user_id,
self.session_id,
m,
)
# Latest 5 of 10 → has_more should be True
_, has_more = await self.storage.list_messages(
self.user_id,
self.session_id,
limit=5,
)
self.assertTrue(has_more)
# Cursor at msgs[5], limit=5 → msgs[0..4], has_more should be False
_, has_more = await self.storage.list_messages(
self.user_id,
self.session_id,
limit=5,
before=msgs[5].id,
)
self.assertFalse(has_more)
async def test_list_messages_invalid_cursor(self) -> None:
"""list_messages with nonexistent cursor returns empty result."""
msg = UserMsg(name="alice", content="hello")
await self.storage.upsert_message(self.user_id, self.session_id, msg)
page, has_more = await self.storage.list_messages(
self.user_id,
self.session_id,
before="nonexistent-id",
)
self.assertFalse(has_more)
self.assertListEqual(page, [])
async def test_find_message_index_across_chunks(self) -> None:
"""_find_message_index locates messages beyond the first chunk."""
msgs = [UserMsg(name="alice", content=f"msg-{i}") for i in range(7)]
for m in msgs:
await self.storage.upsert_message(
self.user_id,
self.session_id,
m,
)
key = self.storage._message_key(self.user_id, self.session_id)
# chunk_size=2 forces the scan to walk several chunks.
for i, m in enumerate(msgs):
idx = await self.storage._find_message_index(key, m.id, 2)
self.assertEqual(idx, i)
idx = await self.storage._find_message_index(key, "nonexistent", 2)
self.assertIsNone(idx)
async def test_list_messages_order_preserved(self) -> None:
"""Messages are returned in the insertion order (chronological)."""
msgs = [
UserMsg(name="alice", content=text)
for text in ["alpha", "beta", "gamma"]
]
for m in msgs:
await self.storage.upsert_message(
self.user_id,
self.session_id,
m,
)
messages, has_more = await self.storage.list_messages(
self.user_id,
self.session_id,
)
self.assertFalse(has_more)
self.assertListEqual(
[m.model_dump() for m in messages],
[m.model_dump() for m in msgs],
)
async def test_session_isolation(self) -> None:
"""Messages belonging to different sessions do not interfere."""
await self.storage.upsert_message(
self.user_id,
"session-A",
UserMsg(name="alice", content="in A"),
)
messages, has_more = await self.storage.list_messages(
self.user_id,
"session-B",
)
self.assertFalse(has_more)
self.assertListEqual(messages, [])
async def test_list_messages_offset_kwarg_warns(self) -> None:
"""Passing deprecated offset via kwargs emits DeprecationWarning."""
msg = UserMsg(name="alice", content="hello")
await self.storage.upsert_message(self.user_id, self.session_id, msg)
with self.assertWarns(DeprecationWarning):
messages, has_more = await self.storage.list_messages(
self.user_id,
self.session_id,
offset=0,
)
# Should still return results (offset is ignored, latest page).
self.assertFalse(has_more)
self.assertEqual(len(messages), 1)
def make_schedule_record(user_id: str, agent_id: str) -> ScheduleRecord:
"""Create a test ScheduleRecord."""
return ScheduleRecord(
user_id=user_id,
agent_id=agent_id,
data=ScheduleData(
name="test-schedule",
cron_expression="0 9 * * *",
started_at="2026-01-01T00:00:00",
chat_model_config=ChatModelConfig(
type="openai",
credential_id="cred-1",
model="gpt-4",
parameters={},
),
),
)
class TestScheduleSession(IsolatedAsyncioTestCase):
"""Tests for schedule-session index and cascade deletion."""
async def asyncSetUp(self) -> None:
"""Set up test fixtures."""
self.storage = make_storage()
self.user_id = "user-1"
self.agent_id = "agent-1"
async def test_list_sessions_by_schedule(self) -> None:
"""Sessions created with source_schedule_id are queryable by
schedule."""
schedule = make_schedule_record(self.user_id, self.agent_id)
await self.storage.upsert_schedule(self.user_id, schedule)
session = await self.storage.upsert_session(
self.user_id,
self.agent_id,
make_session_config(),
origin=ScheduleOrigin(schedule_id=schedule.id),
)
results = await self.storage.list_sessions_by_schedule(
self.user_id,
schedule.id,
)
self.assertEqual(len(results), 1)
self.assertEqual(results[0].id, session.id)
self.assertEqual(
results[0].origin,
ScheduleOrigin(schedule_id=schedule.id),
)
async def test_list_sessions_by_schedule_empty(self) -> None:
"""Returns empty list when no sessions exist for a schedule."""
results = await self.storage.list_sessions_by_schedule(
self.user_id,
"nonexistent-schedule",
)
self.assertEqual(results, [])
async def test_schedule_session_also_in_agent_index(self) -> None:
"""A schedule-created session appears in both the schedule and agent
session indexes."""
schedule = make_schedule_record(self.user_id, self.agent_id)
await self.storage.upsert_schedule(self.user_id, schedule)
session = await self.storage.upsert_session(
self.user_id,
self.agent_id,
make_session_config(),
origin=ScheduleOrigin(schedule_id=schedule.id),
)
agent_sessions = await self.storage.list_sessions(
self.user_id,
self.agent_id,
)
self.assertEqual(len(agent_sessions), 1)
self.assertEqual(agent_sessions[0].id, session.id)
async def test_delete_schedule_cascades_sessions(self) -> None:
"""Deleting a schedule removes all its execution sessions."""
schedule = make_schedule_record(self.user_id, self.agent_id)
await self.storage.upsert_schedule(self.user_id, schedule)
await self.storage.upsert_session(
self.user_id,
self.agent_id,
make_session_config(),
origin=ScheduleOrigin(schedule_id=schedule.id),
)
await self.storage.upsert_session(
self.user_id,
self.agent_id,
make_session_config(),
origin=ScheduleOrigin(schedule_id=schedule.id),
)
await self.storage.delete_schedule(self.user_id, schedule.id)
schedule_sessions = await self.storage.list_sessions_by_schedule(
self.user_id,
schedule.id,
)
self.assertEqual(schedule_sessions, [])
agent_sessions = await self.storage.list_sessions(
self.user_id,
self.agent_id,
)
self.assertEqual(agent_sessions, [])
async def test_delete_session_cleans_schedule_index(self) -> None:
"""Deleting a session removes it from the schedule session index."""
schedule = make_schedule_record(self.user_id, self.agent_id)
await self.storage.upsert_schedule(self.user_id, schedule)
session = await self.storage.upsert_session(
self.user_id,
self.agent_id,
make_session_config(),
origin=ScheduleOrigin(schedule_id=schedule.id),
)
await self.storage.delete_session(
self.user_id,
self.agent_id,
session.id,
)
results = await self.storage.list_sessions_by_schedule(
self.user_id,
schedule.id,
)
self.assertEqual(results, [])
def make_team_record(
user_id: str,
session_id: str = "leader-session-1",
name: str = "test-team",
member_ids: list[str] | None = None,
) -> TeamRecord:
"""Create a test TeamRecord."""
return TeamRecord(
user_id=user_id,
session_id=session_id,
data=TeamData(
name=name,
member_ids=member_ids if member_ids is not None else [],
),
)
class TestAgentSource(IsolatedAsyncioTestCase):
"""Tests for the ``source`` field on AgentRecord."""
async def asyncSetUp(self) -> None:
"""Set up test fixtures."""
self.storage = make_storage()
self.user_id = "user-1"
async def test_default_source_is_user(self) -> None:
"""An AgentRecord built without ``source`` defaults to ``"user"``."""
record = make_agent_record(self.user_id)
self.assertEqual(record.source, "user")
await self.storage.upsert_agent(self.user_id, record)
loaded = await self.storage.get_agent(self.user_id, record.id)
self.assertIsNotNone(loaded)
self.assertEqual(loaded.source, "user")
async def test_team_source_round_trips(self) -> None:
"""A worker AgentRecord persists ``source='team'`` through Redis."""
record = AgentRecord(
user_id=self.user_id,
source="team",
data=AgentData(
id="worker-1",
name="worker",
system_prompt="You are a team worker.",
context_config=ContextConfig(),
react_config=ReActConfig(),
),
)
await self.storage.upsert_agent(self.user_id, record)
loaded = await self.storage.get_agent(self.user_id, record.id)
self.assertIsNotNone(loaded)
self.assertEqual(loaded.source, "team")
async def test_list_agents_filters_out_team_workers(self) -> None:
"""``storage.list_agents`` returns only ``source='user'`` agents.
Workers (``source='team'``) are scoped to a team and addressable
only via direct id lookup."""
user_agent = make_agent_record(self.user_id)
worker = AgentRecord(
id="worker-1",
user_id=self.user_id,
source="team",
data=AgentData(
id="data-w",
name="worker",
system_prompt="",
context_config=ContextConfig(),
react_config=ReActConfig(),
),
)
await self.storage.upsert_agent(self.user_id, user_agent)
await self.storage.upsert_agent(self.user_id, worker)
listed = await self.storage.list_agents(self.user_id)
listed_ids = {a.id for a in listed}
self.assertIn(user_agent.id, listed_ids)
self.assertNotIn(worker.id, listed_ids)
# But direct lookup still works for the worker.
loaded_worker = await self.storage.get_agent(
self.user_id,
worker.id,
)
self.assertIsNotNone(loaded_worker)
self.assertEqual(loaded_worker.source, "team")
async def test_legacy_record_without_source_deserializes(self) -> None:
"""JSON written before the ``source`` field was added still loads
and falls back to the default ``"user"``."""
legacy_record = make_agent_record(self.user_id)
legacy_json = legacy_record.model_dump_json()
# Strip the new field to simulate pre-migration data.
import json
payload = json.loads(legacy_json)
payload.pop("source", None)
# pylint: disable=protected-access
key = self.storage._key(
self.storage.key_config.agent,
user_id=self.user_id,
agent_id=legacy_record.id,
)
await self.storage._client.set(key, json.dumps(payload))
await self.storage._client.sadd(
self.storage._key(
self.storage.key_config.agent_index,
user_id=self.user_id,
),
legacy_record.id,
)
loaded = await self.storage.get_agent(self.user_id, legacy_record.id)
self.assertIsNotNone(loaded)
self.assertEqual(loaded.source, "user")
class TestSessionTeamId(IsolatedAsyncioTestCase):
"""Tests for the ``team_id`` field on SessionRecord."""
async def asyncSetUp(self) -> None:
"""Set up test fixtures."""
self.storage = make_storage()
self.user_id = "user-1"
self.agent_id = "agent-1"
async def test_default_team_id_is_none(self) -> None:
"""A SessionRecord built without ``team_id`` defaults to ``None``."""
session = await self.storage.upsert_session(
self.user_id,
self.agent_id,
make_session_config(),
)
self.assertIsNone(session.team_id)
loaded = await self.storage.get_session(
self.user_id,
self.agent_id,
session.id,
)
self.assertIsNotNone(loaded)
self.assertIsNone(loaded.team_id)
async def test_legacy_session_without_team_id_deserializes(self) -> None:
"""JSON written before ``team_id`` existed still loads with default
``None``."""
session = await self.storage.upsert_session(
self.user_id,
self.agent_id,
make_session_config(),
)
# Strip the new field from the persisted JSON to simulate pre-migration
# data, then write it back at the same key.
import json
# pylint: disable=protected-access
key = self.storage._key(
self.storage.key_config.session,
user_id=self.user_id,
session_id=session.id,
)
raw = await self.storage._client.get(key)
payload = json.loads(raw)
payload.pop("team_id", None)
await self.storage._client.set(key, json.dumps(payload))
loaded = await self.storage.get_session(
self.user_id,
self.agent_id,
session.id,
)
self.assertIsNotNone(loaded)
self.assertIsNone(loaded.team_id)
class TestTeam(IsolatedAsyncioTestCase):
"""Tests for team CRUD."""
async def asyncSetUp(self) -> None:
"""Set up test fixtures."""
self.storage = make_storage()
self.user_id = "user-1"
async def test_create(self) -> None:
"""Create a team and verify it is retrievable via list."""
record = make_team_record(self.user_id)
stored = await self.storage.upsert_team(self.user_id, record)
records = await self.storage.list_teams(self.user_id)
self.assertEqual(len(records), 1)
self.assertEqual(records[0].id, stored.id)
self.assertEqual(records[0].session_id, "leader-session-1")
self.assertEqual(records[0].data.name, "test-team")
self.assertEqual(records[0].data.member_ids, [])
async def test_list_empty(self) -> None:
"""Verify list returns empty when no teams exist."""
records = await self.storage.list_teams(self.user_id)
self.assertEqual(records, [])
async def test_get_returns_record(self) -> None:
"""get_team returns the persisted record by id."""
record = make_team_record(
self.user_id,
member_ids=["worker-a", "worker-b"],
)
await self.storage.upsert_team(self.user_id, record)
loaded = await self.storage.get_team(self.user_id, record.id)
self.assertIsNotNone(loaded)
self.assertEqual(loaded.id, record.id)
self.assertEqual(loaded.data.member_ids, ["worker-a", "worker-b"])
async def test_get_nonexistent_returns_none(self) -> None:
"""get_team returns None when the id does not exist."""
loaded = await self.storage.get_team(self.user_id, "no-such-id")
self.assertIsNone(loaded)
async def test_update_in_place(self) -> None:
"""Upsert with the same id overwrites the existing record."""
record = make_team_record(self.user_id, name="original")
await self.storage.upsert_team(self.user_id, record)
record.data.name = "renamed"
record.data.member_ids = ["new-worker"]
await self.storage.upsert_team(self.user_id, record)
records = await self.storage.list_teams(self.user_id)
self.assertEqual(len(records), 1)
self.assertEqual(records[0].data.name, "renamed")
self.assertEqual(records[0].data.member_ids, ["new-worker"])
async def test_upsert_refreshes_updated_at(self) -> None:
"""upsert_team bumps ``updated_at`` on each write."""
record = make_team_record(self.user_id)
first = await self.storage.upsert_team(self.user_id, record)
first_updated = first.updated_at
# Second write must have a strictly non-decreasing updated_at.
second = await self.storage.upsert_team(self.user_id, record)
self.assertGreaterEqual(second.updated_at, first_updated)
async def test_delete(self) -> None:
"""Delete a team and verify it is gone from Redis and the index."""
record = make_team_record(self.user_id)
await self.storage.upsert_team(self.user_id, record)
result = await self.storage.delete_team(self.user_id, record.id)
self.assertTrue(result)
loaded = await self.storage.get_team(self.user_id, record.id)
self.assertIsNone(loaded)
self.assertEqual(await self.storage.list_teams(self.user_id), [])
async def test_delete_nonexistent(self) -> None:
"""delete_team returns False for an unknown id."""
result = await self.storage.delete_team(self.user_id, "no-such-id")
self.assertFalse(result)
async def test_user_isolation(self) -> None:
"""Teams from one user are invisible to another."""
await self.storage.upsert_team(
"user-A",
make_team_record("user-A"),
)
records = await self.storage.list_teams("user-B")
self.assertEqual(records, [])
def make_worker_agent(user_id: str, agent_id: str) -> AgentRecord:
"""Create a source='team' worker AgentRecord."""
return AgentRecord(
id=agent_id,
user_id=user_id,
source="team",
data=AgentData(
id=f"data-{agent_id}",
name=f"name-{agent_id}",
system_prompt="worker",
context_config=ContextConfig(),
react_config=ReActConfig(),
),
)
class TestTeamCascade(IsolatedAsyncioTestCase):
"""End-to-end cascade tests for the team relationship graph."""
async def asyncSetUp(self) -> None:
"""Build a small team fixture: 1 leader user-agent + 2 workers."""
self.storage = make_storage()
self.user_id = "user-1"
# Leader agent (user-created) and its session
self.leader_agent = make_agent_record(self.user_id)
await self.storage.upsert_agent(self.user_id, self.leader_agent)
leader_session = await self.storage.upsert_session(
self.user_id,
self.leader_agent.id,
make_session_config(),
)
self.leader_session_id = leader_session.id
# Two worker agents and their sessions
self.worker_a = make_worker_agent(self.user_id, "worker-a")
self.worker_b = make_worker_agent(self.user_id, "worker-b")
await self.storage.upsert_agent(self.user_id, self.worker_a)
await self.storage.upsert_agent(self.user_id, self.worker_b)
worker_a_session = await self.storage.upsert_session(
self.user_id,
self.worker_a.id,
make_session_config(),
)
worker_b_session = await self.storage.upsert_session(
self.user_id,
self.worker_b.id,
make_session_config(),
)
self.worker_a_session_id = worker_a_session.id
self.worker_b_session_id = worker_b_session.id
# The team itself + leader's team_id back-reference
self.team = make_team_record(
self.user_id,
session_id=self.leader_session_id,
member_ids=[self.worker_a.id, self.worker_b.id],
)
await self.storage.upsert_team(self.user_id, self.team)
# Stamp team_id on every team-participating session
# pylint: disable=protected-access
for sid in [
self.leader_session_id,
self.worker_a_session_id,
self.worker_b_session_id,
]:
session_key = self.storage._key(
self.storage.key_config.session,
user_id=self.user_id,
session_id=sid,
)
raw = await self.storage._client.get(session_key)
rec = SessionRecord.model_validate_json(raw)
rec.team_id = self.team.id
await self.storage._client.set(session_key, rec.model_dump_json())
async def test_delete_team_cascades_workers_and_clears_leader(
self,
) -> None:
"""delete_team removes all workers + sessions + clears leader."""
result = await self.storage.delete_team(self.user_id, self.team.id)
self.assertTrue(result)
# Team record gone
self.assertIsNone(
await self.storage.get_team(self.user_id, self.team.id),
)
# Worker agents gone
self.assertIsNone(
await self.storage.get_agent(self.user_id, self.worker_a.id),
)
self.assertIsNone(
await self.storage.get_agent(self.user_id, self.worker_b.id),
)
# Worker sessions gone
self.assertIsNone(
await self.storage.get_session(
self.user_id,
self.worker_a.id,
self.worker_a_session_id,
),
)
# Leader session still exists, team_id cleared
leader = await self.storage.get_session(
self.user_id,
self.leader_agent.id,
self.leader_session_id,
)
self.assertIsNotNone(leader)
self.assertIsNone(leader.team_id)
async def test_delete_team_removes_cross_owner_borrowed_session(
self,
) -> None:
"""An invited definition owner differs from its session owner."""
definition_owner = "user-2"
invited = make_agent_record(definition_owner)
await self.storage.upsert_agent(definition_owner, invited)
owner_session = await self.storage.upsert_session(
definition_owner,
invited.id,
make_session_config("owner-private-workspace"),
)
borrowed = await self.storage.upsert_session(
self.user_id,
invited.id,
make_session_config("viewer-borrowed-workspace"),
)
self.team.data.members = [
TeamMember(
owner_id=definition_owner,
agent_id=invited.id,
session_id=borrowed.id,
role="invited",
),
]
self.team.data.member_ids = [invited.id]
await self.storage.upsert_team(self.user_id, self.team)
self.assertTrue(
await self.storage.delete_team(self.user_id, self.team.id),
)
self.assertIsNone(
await self.storage.get_session(
self.user_id,
invited.id,
borrowed.id,
),
)
self.assertIsNotNone(
await self.storage.get_session(
definition_owner,
invited.id,
owner_session.id,
),
)
self.assertIsNotNone(
await self.storage.get_agent(definition_owner, invited.id),
)
async def test_delete_leader_session_dissolves_team(self) -> None:
"""Deleting a leader session auto-dissolves its team."""
await self.storage.delete_session(
self.user_id,
self.leader_agent.id,
self.leader_session_id,
)
# Team gone
self.assertIsNone(
await self.storage.get_team(self.user_id, self.team.id),
)
# Workers gone
self.assertIsNone(
await self.storage.get_agent(self.user_id, self.worker_a.id),
)
# Leader agent itself still exists (only the session was deleted)
self.assertIsNotNone(
await self.storage.get_agent(self.user_id, self.leader_agent.id),
)
async def test_delete_leader_agent_dissolves_all_its_teams(self) -> None:
"""Deleting the leader agent dissolves every team it leads."""
await self.storage.delete_agent(self.user_id, self.leader_agent.id)
self.assertIsNone(
await self.storage.get_team(self.user_id, self.team.id),
)
self.assertIsNone(
await self.storage.get_agent(self.user_id, self.worker_a.id),
)
self.assertIsNone(
await self.storage.get_agent(self.user_id, self.leader_agent.id),
)
async def test_direct_delete_worker_agent_scrubs_member_ids(self) -> None:
"""Bypassing delete_team still keeps team.member_ids consistent."""
await self.storage.delete_agent(self.user_id, self.worker_a.id)
team = await self.storage.get_team(self.user_id, self.team.id)
self.assertIsNotNone(team)
self.assertEqual(team.data.member_ids, [self.worker_b.id])
# The other worker is untouched
self.assertIsNotNone(
await self.storage.get_agent(self.user_id, self.worker_b.id),
)
async def test_direct_delete_worker_session_does_not_dissolve_team(
self,
) -> None:
"""Deleting a worker's session leaves the team intact (asymmetric
with leader-session deletion — there's no FK from session to its
owning agent)."""
await self.storage.delete_session(
self.user_id,
self.worker_a.id,
self.worker_a_session_id,
)
# Team and worker agent still exist
self.assertIsNotNone(
await self.storage.get_team(self.user_id, self.team.id),
)
self.assertIsNotNone(
await self.storage.get_agent(self.user_id, self.worker_a.id),
)
# The session is gone though
self.assertIsNone(
await self.storage.get_session(
self.user_id,
self.worker_a.id,
self.worker_a_session_id,
),
)
async def test_delete_team_idempotent_on_nonexistent(self) -> None:
"""delete_team on a missing team returns False without crashing."""
result = await self.storage.delete_team(self.user_id, "no-such-id")
self.assertFalse(result)
def make_mcp_record(
user_id: str,
name: str = "deepwiki",
**kwargs: object,
) -> MCPRecord:
"""Create a test MCPRecord wrapping a stateless HTTP MCP."""
return MCPRecord(
user_id=user_id,
client=MCPClient(
name=name,
is_stateful=False,
mcp_config=HttpMCPConfig(url="https://mcp.deepwiki.com/mcp"),
),
**kwargs,
)
class TestMCP(IsolatedAsyncioTestCase):
"""Tests for installed-MCP CRUD and the per-user name uniqueness."""
async def asyncSetUp(self) -> None:
"""Set up test fixtures."""
self.storage = make_storage()
self.user_id = "user-mcp"
async def test_upsert_and_get_roundtrip(self) -> None:
"""A written record comes back with its provenance intact."""
record = make_mcp_record(
self.user_id,
hub_id="static",
card_id="deepwiki",
version="1.0.0",
)
mcp_id = await self.storage.upsert_mcp(self.user_id, record)
fetched = await self.storage.get_mcp(self.user_id, mcp_id)
self.assertIsNotNone(fetched)
self.assertEqual(fetched.client.name, "deepwiki")
self.assertEqual(fetched.client.mcp_config.type, "http_mcp")
self.assertEqual(fetched.hub_id, "static")
self.assertEqual(fetched.card_id, "deepwiki")
self.assertEqual(fetched.version, "1.0.0")
self.assertTrue(fetched.enabled)
async def test_manually_added_mcp_has_no_provenance(self) -> None:
"""An MCP added by hand still gets a record, just without a hub."""
record = make_mcp_record(self.user_id, name="hand-rolled")
await self.storage.upsert_mcp(self.user_id, record)
fetched = await self.storage.get_mcp_by_name(
self.user_id,
"hand-rolled",
)
self.assertIsNotNone(fetched)
self.assertIsNone(fetched.hub_id)
self.assertIsNone(fetched.card_id)
async def test_duplicate_name_rejected(self) -> None:
"""Two records may not share a name — the workspace joins on it."""
await self.storage.upsert_mcp(
self.user_id,
make_mcp_record(self.user_id),
)
with self.assertRaises(ValueError):
await self.storage.upsert_mcp(
self.user_id,
make_mcp_record(self.user_id),
)
async def test_same_name_across_users_allowed(self) -> None:
"""Uniqueness is per user, not global."""
await self.storage.upsert_mcp(
self.user_id,
make_mcp_record(self.user_id),
)
other = await self.storage.upsert_mcp(
"other-user",
make_mcp_record("other-user"),
)
self.assertIsNotNone(await self.storage.get_mcp("other-user", other))
async def test_update_in_place_keeps_name_claim(self) -> None:
"""Re-upserting the same record is an update, not a name clash."""
record = make_mcp_record(self.user_id)
mcp_id = await self.storage.upsert_mcp(self.user_id, record)
record.enabled = False
await self.storage.upsert_mcp(self.user_id, record)
fetched = await self.storage.get_mcp(self.user_id, mcp_id)
self.assertFalse(fetched.enabled)
self.assertEqual(len(await self.storage.list_mcps(self.user_id)), 1)
async def test_rename_releases_the_old_name(self) -> None:
"""After a rename the old name is free and no longer resolves."""
record = make_mcp_record(self.user_id)
await self.storage.upsert_mcp(self.user_id, record)
record.client.name = "deepwiki-2"
await self.storage.upsert_mcp(self.user_id, record)
self.assertIsNone(
await self.storage.get_mcp_by_name(self.user_id, "deepwiki"),
)
self.assertIsNotNone(
await self.storage.get_mcp_by_name(self.user_id, "deepwiki-2"),
)
# The freed name can now be claimed by a different record
await self.storage.upsert_mcp(
self.user_id,
make_mcp_record(self.user_id),
)
self.assertEqual(len(await self.storage.list_mcps(self.user_id)), 2)
async def test_delete_frees_the_name(self) -> None:
"""Deleting a record releases its name for reuse."""
record = make_mcp_record(self.user_id)
mcp_id = await self.storage.upsert_mcp(self.user_id, record)
self.assertTrue(await self.storage.delete_mcp(self.user_id, mcp_id))
self.assertIsNone(
await self.storage.get_mcp_by_name(self.user_id, "deepwiki"),
)
self.assertEqual(await self.storage.list_mcps(self.user_id), [])
await self.storage.upsert_mcp(
self.user_id,
make_mcp_record(self.user_id),
)
async def test_delete_missing_returns_false(self) -> None:
"""delete_mcp on a missing record returns False without crashing."""
self.assertFalse(
await self.storage.delete_mcp(self.user_id, "no-such-id"),
)
async def test_get_by_unknown_name_returns_none(self) -> None:
"""An unclaimed name resolves to nothing."""
self.assertIsNone(
await self.storage.get_mcp_by_name(self.user_id, "nope"),
)
def make_skill_record(
user_id: str,
name: str = "gifgrep",
**kwargs: object,
) -> SkillRecord:
"""Create a test SkillRecord."""
return SkillRecord(user_id=user_id, name=name, **kwargs)
class TestSkill(IsolatedAsyncioTestCase):
"""Tests for installed-skill CRUD and per-user name uniqueness."""
async def asyncSetUp(self) -> None:
"""Set up test fixtures."""
self.storage = make_storage()
self.user_id = "user-skill"
async def test_upsert_and_get_roundtrip(self) -> None:
"""A written record comes back with its provenance intact."""
record = make_skill_record(
self.user_id,
hub_id="clawhub",
card_id="gifgrep",
version="1.0.1",
markdown="# gifgrep",
)
skill_id = await self.storage.upsert_skill(self.user_id, record)
fetched = await self.storage.get_skill(
self.user_id,
skill_id,
)
self.assertIsNotNone(fetched)
self.assertEqual(fetched.name, "gifgrep")
self.assertEqual(fetched.hub_id, "clawhub")
self.assertEqual(fetched.markdown, "# gifgrep")
self.assertTrue(fetched.enabled)
async def test_duplicate_name_rejected(self) -> None:
"""Two records may not share a name."""
await self.storage.upsert_skill(
self.user_id,
make_skill_record(self.user_id),
)
with self.assertRaises(ValueError):
await self.storage.upsert_skill(
self.user_id,
make_skill_record(self.user_id),
)
async def test_same_name_across_users_allowed(self) -> None:
"""Uniqueness is per user, not global."""
await self.storage.upsert_skill(
self.user_id,
make_skill_record(self.user_id),
)
other = await self.storage.upsert_skill(
"other-user",
make_skill_record("other-user"),
)
self.assertIsNotNone(
await self.storage.get_skill("other-user", other),
)
async def test_update_in_place_keeps_name_claim(self) -> None:
"""Re-upserting the same record is an update, not a name clash."""
record = make_skill_record(self.user_id)
skill_id = await self.storage.upsert_skill(self.user_id, record)
record.enabled = False
await self.storage.upsert_skill(self.user_id, record)
fetched = await self.storage.get_skill(
self.user_id,
skill_id,
)
self.assertFalse(fetched.enabled)
self.assertEqual(
len(await self.storage.list_skills(self.user_id)),
1,
)
async def test_rename_releases_the_old_name(self) -> None:
"""After a rename the old name is free and no longer resolves."""
record = make_skill_record(self.user_id)
await self.storage.upsert_skill(self.user_id, record)
record.name = "gifgrep-2"
await self.storage.upsert_skill(self.user_id, record)
self.assertIsNone(
await self.storage.get_skill_by_name(
self.user_id,
"gifgrep",
),
)
self.assertIsNotNone(
await self.storage.get_skill_by_name(
self.user_id,
"gifgrep-2",
),
)
await self.storage.upsert_skill(
self.user_id,
make_skill_record(self.user_id),
)
self.assertEqual(
len(await self.storage.list_skills(self.user_id)),
2,
)
async def test_delete_frees_the_name(self) -> None:
"""Deleting a record releases its name for reuse."""
record = make_skill_record(self.user_id)
skill_id = await self.storage.upsert_skill(self.user_id, record)
self.assertTrue(
await self.storage.delete_skill(self.user_id, skill_id),
)
self.assertIsNone(
await self.storage.get_skill_by_name(
self.user_id,
"gifgrep",
),
)
self.assertEqual(
await self.storage.list_skills(self.user_id),
[],
)
await self.storage.upsert_skill(
self.user_id,
make_skill_record(self.user_id),
)
async def test_delete_missing_returns_false(self) -> None:
"""Deleting a missing record returns False without crashing."""
self.assertFalse(
await self.storage.delete_skill(
self.user_id,
"no-such-id",
),
)
async def test_mcp_and_skill_libraries_are_independent(self) -> None:
"""The two name indexes do not collide."""
await self.storage.upsert_mcp(
self.user_id,
make_mcp_record(self.user_id, name="shared"),
)
await self.storage.upsert_skill(
self.user_id,
make_skill_record(self.user_id, name="shared"),
)
self.assertEqual(len(await self.storage.list_mcps(self.user_id)), 1)
self.assertEqual(
len(await self.storage.list_skills(self.user_id)),
1,
)
class TestChannelSessionIndex(IsolatedAsyncioTestCase):
"""The channel index, which the tagged union now drives.
It used to be written from a nullable ``source_channel_id``; it is
now written from a ``ChannelOrigin``, and the schedule path's
coverage says nothing about it.
"""
async def asyncSetUp(self) -> None:
"""Set up test fixtures."""
self.storage = make_storage()
self.user_id = "user-1"
self.agent_id = "agent-1"
async def test_a_channel_session_is_indexed_and_unindexed(self) -> None:
"""It is found by its channel, and gone once the session is."""
session = await self.storage.upsert_session(
self.user_id,
self.agent_id,
make_session_config(),
origin=ChannelOrigin(
channel_id="chan-1",
chat_id="chat-1",
chat_name="产品群",
),
)
found = await self.storage.list_sessions_by_channel(
self.user_id,
"chan-1",
)
self.assertEqual(len(found), 1)
self.assertEqual(found[0].id, session.id)
self.assertEqual(
found[0].origin,
ChannelOrigin(
channel_id="chan-1",
chat_id="chat-1",
chat_name="产品群",
),
)
await self.storage.delete_session(
self.user_id,
self.agent_id,
session.id,
)
self.assertEqual(
await self.storage.list_sessions_by_channel(
self.user_id,
"chan-1",
),
[],
)
async def test_a_session_from_elsewhere_is_not_indexed(self) -> None:
"""Only a ChannelOrigin goes into the channel index."""
await self.storage.upsert_session(
self.user_id,
self.agent_id,
make_session_config(),
)
self.assertEqual(
await self.storage.list_sessions_by_channel(
self.user_id,
"chan-1",
),
[],
)
# A procedure needs at least one milestone, so the fixtures that only
# care about the record around it still carry one.
_A_STEP = SOPStepDataV1(
subject="model",
description="make the hull",
executor=SOPAgentRef(agent_id="a-1", session_key="modeller"),
)
def make_sop_record(user_id: str) -> SOPRecord:
"""A one-step procedure."""
return SOPRecord(
user_id=user_id,
data=SOPData(
name="ship",
description="build one",
steps=[
SOPStepDataV1(
subject="model",
description="make the hull",
executor=SOPAgentRef(
agent_id="agent-1",
session_key="modeller",
),
),
],
),
)
class TestSOP(IsolatedAsyncioTestCase):
"""Tests for SOP and SOP run CRUD."""
async def asyncSetUp(self) -> None:
"""Set up test fixtures."""
self.storage = make_storage()
self.user_id = "user-1"
async def test_round_trip(self) -> None:
"""A stored procedure comes back whole."""
record = make_sop_record(self.user_id)
await self.storage.upsert_sop(self.user_id, record)
fetched = await self.storage.get_sop(self.user_id, record.id)
self.maxDiff = None
self.assertDictEqual(
fetched.model_dump(mode="json"),
{
"id": AnyString(),
"created_at": AnyString(),
"updated_at": AnyString(),
"user_id": "user-1",
"data": {
"name": "ship",
"description": "build one",
"steps": [
{
"version": "v1",
"subject": "model",
"description": "make the hull",
"executor": {
"agent_id": "agent-1",
"session_key": "modeller",
},
"verifier": None,
"max_attempts": 3,
},
],
"workspace_grain": "run",
"session_settings": {},
},
},
)
self.assertEqual(
[_.id for _ in await self.storage.list_sops(self.user_id)],
[record.id],
)
async def test_user_isolation(self) -> None:
"""One user's procedures are invisible to another."""
record = make_sop_record("user-A")
await self.storage.upsert_sop("user-A", record)
self.assertEqual(await self.storage.list_sops("user-B"), [])
self.assertIsNone(await self.storage.get_sop("user-B", record.id))
async def test_delete(self) -> None:
"""Deleting twice reports the second as a miss."""
record = make_sop_record(self.user_id)
await self.storage.upsert_sop(self.user_id, record)
self.assertTrue(await self.storage.delete_sop(self.user_id, record.id))
self.assertFalse(
await self.storage.delete_sop(self.user_id, record.id),
)
self.assertEqual(await self.storage.list_sops(self.user_id), [])
async def test_runs_are_listed_by_procedure_and_phase(self) -> None:
"""The per-procedure index narrows the read; phase filters after."""
waiting = SOPRunRecord(
user_id=self.user_id,
sop_id="sop-1",
definition=SOPData(name="a", steps=[_A_STEP]),
state=SOPRunState(
steps=[SOPStepRunState(phase=SOPPhase.AWAITING)],
),
)
done = SOPRunRecord(
user_id=self.user_id,
sop_id="sop-1",
definition=SOPData(name="a", steps=[_A_STEP]),
state=SOPRunState(
steps=[SOPStepRunState(phase=SOPPhase.COMPLETED)],
),
)
other = SOPRunRecord(
user_id=self.user_id,
sop_id="sop-2",
definition=SOPData(name="b", steps=[_A_STEP]),
state=SOPRunState(
steps=[SOPStepRunState(phase=SOPPhase.AWAITING)],
),
)
for record in (waiting, done, other):
await self.storage.upsert_sop_run(self.user_id, record)
self.assertEqual(
{
_.id
for _ in await self.storage.list_sop_runs(
self.user_id,
sop_id="sop-1",
)
},
{waiting.id, done.id},
)
self.assertEqual(
{
_.id
for _ in await self.storage.list_sop_runs(
self.user_id,
phase=SOPPhase.AWAITING,
)
},
{waiting.id, other.id},
)
async def test_update_run_writes_state_and_sessions(self) -> None:
"""The hot path rewrites what moves and keeps the snapshot."""
run = SOPRunRecord(
user_id=self.user_id,
sop_id="sop-1",
definition=SOPData(name="ship", steps=[_A_STEP]),
state=SOPRunState(steps=[SOPStepRunState()]),
)
await self.storage.upsert_sop_run(self.user_id, run)
await self.storage.update_sop_run(
self.user_id,
run.id,
SOPRunState(steps=[SOPStepRunState(phase=SOPPhase.AWAITING)]),
sessions={"modeller": "session-1"},
)
updated = await self.storage.get_sop_run(self.user_id, run.id)
self.maxDiff = None
self.assertDictEqual(
updated.model_dump(mode="json"),
{
"id": run.id,
"created_at": AnyString(),
"updated_at": AnyString(),
"user_id": "user-1",
"sop_id": "sop-1",
"definition": {
"name": "ship",
"description": "",
"steps": [
{
"version": "v1",
"subject": "model",
"description": "make the hull",
"executor": {
"agent_id": "a-1",
"session_key": "modeller",
},
"verifier": None,
"max_attempts": 3,
},
],
"workspace_grain": "run",
"session_settings": {},
},
"sessions": {"modeller": "session-1"},
"state": {
"id": AnyString(),
"inputs": [],
"steps": [
{
"phase": "awaiting",
"given": [],
"submission": None,
"verifications": [],
},
],
"created_at": AnyString(),
"phase": "awaiting",
},
},
)
with self.assertRaises(KeyError):
await self.storage.update_sop_run(
self.user_id,
"no-such-id",
SOPRunState(),
)
async def test_deleting_a_sop_takes_its_runs_with_it(self) -> None:
"""A run is only readable through the definition it snapshotted."""
sop = make_sop_record(self.user_id)
await self.storage.upsert_sop(self.user_id, sop)
run = SOPRunRecord(
user_id=self.user_id,
sop_id=sop.id,
definition=sop.data,
)
await self.storage.upsert_sop_run(self.user_id, run)
await self.storage.delete_sop(self.user_id, sop.id)
self.assertIsNone(await self.storage.get_sop_run(self.user_id, run.id))
self.assertEqual(await self.storage.list_sop_runs(self.user_id), [])
async def test_deleting_a_run_takes_its_sessions(self) -> None:
"""The run minted them, so none is left behind to be woken."""
await self.storage.upsert_agent(
self.user_id,
make_agent_record(self.user_id),
)
agents = await self.storage.list_agents(self.user_id)
session = await self.storage.upsert_session(
user_id=self.user_id,
agent_id=agents[0].id,
config=SessionConfig(workspace_id="ws-1"),
)
run = SOPRunRecord(
user_id=self.user_id,
sop_id="sop-1",
definition=SOPData(name="ship", steps=[_A_STEP]),
sessions={"modeller": session.id},
)
await self.storage.upsert_sop_run(self.user_id, run)
self.assertTrue(
await self.storage.delete_sop_run(self.user_id, run.id),
)
self.assertIsNone(
await self.storage.get_session(
self.user_id,
agents[0].id,
session.id,
),
)
async def test_a_step_state_subclass_survives_redis(self) -> None:
"""What a step kept beyond the base record is stored, not trimmed."""
run = SOPRunRecord(
user_id=self.user_id,
sop_id="sop-1",
definition=SOPData(name="ship", steps=[_A_STEP]),
state=SOPRunState(
steps=[SOPStepRunState(phase=SOPPhase.AWAITING, call_id="c1")],
),
)
await self.storage.upsert_sop_run(self.user_id, run)
fetched = await self.storage.get_sop_run(self.user_id, run.id)
self.assertDictEqual(
fetched.state.steps[0].model_dump(mode="json"),
{
"phase": "awaiting",
"given": [],
"submission": None,
"verifications": [],
"call_id": "c1",
},
)
class TestVoiceProfileTimestamps(IsolatedAsyncioTestCase):
"""Voice profile writes refresh timestamps in Redis as in SQL."""
async def test_upsert_refreshes_updated_at(self) -> None:
"""Insert and update refresh the stored record's modification time."""
storage = make_storage()
self.addAsyncCleanup(storage._client.aclose)
record = VoiceProfileRecord(
user_id="owner",
data=VoiceProfileData(name="Voice"),
)
created_at = record.created_at
for moment in (DateTime(2026, 1, 1), DateTime(2026, 1, 2)):
with self.subTest(moment=moment):
with patch(
"agentscope.app.storage._redis_storage.datetime",
) as clock:
clock.now.return_value = moment
await storage.upsert_voice_profile("owner", record)
self.assertEqual(record.updated_at, moment)
self.assertEqual(record.created_at, created_at)
stored = await storage.get_voice_profile("owner", record.id)
self.assertEqual(stored.model_dump(), record.model_dump())
class TestRecordKeyTTL(IsolatedAsyncioTestCase):
"""Record writes store the value and its TTL in one SET command."""
async def asyncSetUp(self) -> None:
"""Set up test fixtures."""
self.storage = make_storage()
self.addAsyncCleanup(self.storage._client.aclose)
async def _value_and_ttl(self, key: str) -> tuple[str | None, int]:
"""Read back a key's value and remaining TTL."""
client = self.storage._client
return await client.get(key), await client.ttl(key)
async def test_first_write_expires(self) -> None:
"""A new key is written with the configured TTL."""
self.storage.key_ttl = 60
await self.storage._set_with_ttl("probe", "new")
result = await self._value_and_ttl("probe")
self.assertEqual(result, ("new", AnyValue()))
self.assertGreater(result[1], 0)
self.assertLessEqual(result[1], 60)
async def test_overwrite_keeps_key_expiring(self) -> None:
"""Overwriting an expiring or persistent key leaves it expiring."""
self.storage.key_ttl = 60
await self.storage._client.set("expiring", "old", ex=5)
await self.storage._client.set("persistent", "old")
for key in ("expiring", "persistent"):
with self.subTest(key=key):
await self.storage._set_with_ttl(key, "new")
result = await self._value_and_ttl(key)
self.assertEqual(result, ("new", AnyValue()))
self.assertGreater(result[1], 5)
self.assertLessEqual(result[1], 60)
async def test_no_ttl_configured_keeps_key_persistent(self) -> None:
"""With key_ttl None, records are written without an expiry."""
self.storage.key_ttl = None
await self.storage._set_with_ttl("probe", "new")
self.assertEqual(await self._value_and_ttl("probe"), ("new", -1))
async def test_no_ttl_configured_clears_existing_expiry(self) -> None:
"""With key_ttl None, overwriting a key removes its expiry."""
self.storage.key_ttl = None
await self.storage._client.set("probe", "old", ex=60)
await self.storage._set_with_ttl("probe", "new")
self.assertEqual(await self._value_and_ttl("probe"), ("new", -1))
async def test_failure_after_set_cannot_drop_ttl(self) -> None:
"""A failing EXPIRE cannot leave the rewritten key persistent."""
self.storage.key_ttl = 60
await self.storage._client.set("probe", "old", ex=60)
with patch.object(
self.storage._client,
"expire",
side_effect=ConnectionError("injected"),
):
await self.storage._set_with_ttl("probe", "new")
result = await self._value_and_ttl("probe")
self.assertEqual(result, ("new", AnyValue()))
self.assertGreater(result[1], 0)
self.assertLessEqual(result[1], 60)
async def test_voice_profile_write_expires(self) -> None:
"""Voice profile records get the configured TTL like other records."""
self.storage.key_ttl = 60
record = VoiceProfileRecord(
user_id="owner",
data=VoiceProfileData(name="Voice"),
)
await self.storage.upsert_voice_profile("owner", record)
key = self.storage._key(
self.storage.key_config.voice_profile,
user_id="owner",
profile_id=record.id,
)
result = await self._value_and_ttl(key)
self.assertEqual(result, (record.model_dump_json(), AnyValue()))
self.assertGreater(result[1], 0)
self.assertLessEqual(result[1], 60)