deer-flow/backend/tests/test_migration_0042_channel_leases.py
Totoro c994826d06
feat(channels): generalize group notifications and add opt-in task/goal IM notices (#6903)
* feat(channels): generalize IM group targets and add task/goal run notifications

- Generalize proactive group notification capability (proactive_group_notifications), binding validation, and scheduled task group selection across Feishu, QQ, and WeCom while keeping WeChat personal-only.
- Add QQ group active notification delivery via POST /v2/groups/{group_openid}/messages (msg_type=2) and WeCom group active notification delivery via WS Client.sendMessage(chatid, body) with bot_id:group:chatid workspace isolation.
- Generalize notification outbox sources via migration 0043_runtime_im_notices (source_kind, source_key, run_id, nullable task_id/task_run_id) with backward-compatible SQLite/PostgreSQL upgrades.
- Add opt-in ordinary task & goal run IM notifications (run_completed, run_failed, human_input_requested) on the shared outbox, delivery worker, renderer, and settings UI.

* fix(notifications): address review feedback and group/runtime notification edge cases

* test(migrations): update CURRENT_HEAD to 0043_runtime_im_notices across migration chain tests

* fix(channels): preserve group binding names and legacy authorization

Carry owner-chosen group names through existing connect state, keep private bindings out of legacy group fallback, and restore completion metadata retries. Cover real binding and worker finalization paths and synchronize notification docs.

---------

Co-authored-by: Willem Jiang <willem.jiang@gmail.com>
2026-10-15 10:30:55 +08:00

162 lines
7.0 KiB
Python

"""Migration 0042: the shared ``channel_leases`` table (per-provider IM transport leader lease)."""
from __future__ import annotations
import asyncio
import os
import uuid
import pytest
import sqlalchemy as sa
from alembic import command
from alembic.autogenerate import compare_metadata
from alembic.migration import MigrationContext
from alembic.script import ScriptDirectory
from sqlalchemy.ext.asyncio import create_async_engine
from support.postgres import asyncpg_test_url
from deerflow.persistence import bootstrap
from deerflow.persistence.base import Base
from deerflow.persistence.channel_leases import ChannelLeaseRow
from deerflow.persistence.postgres_schema import build_asyncpg_connect_args
REVISION = "0042_channel_leases"
PREVIOUS = "0041_im_notice_preferences"
CURRENT_HEAD = "0043_runtime_im_notices"
TABLE = "channel_leases"
COLUMNS = {"provider", "owner_id", "epoch", "lease_expires_at", "transport_running", "updated_at"}
pytestmark = pytest.mark.asyncio
async def test_0042_remains_in_the_single_migration_chain():
script = ScriptDirectory(str(bootstrap._MIGRATIONS_DIR))
assert script.get_heads() == [CURRENT_HEAD]
assert script.get_revision(CURRENT_HEAD).down_revision == REVISION
assert script.get_revision(REVISION).down_revision == PREVIOUS
# alembic_version.version_num is VARCHAR(32).
assert len(REVISION) <= 32
def _engine(tmp_path, backend):
if backend == "sqlite":
return create_async_engine(f"sqlite+aiosqlite:///{tmp_path / 'migration.db'}"), None
uri = os.environ.get("TEST_POSTGRES_URI")
if not uri:
pytest.skip("requires TEST_POSTGRES_URI (real Postgres migration 0042)")
schema = f"channel_leases_{uuid.uuid4().hex}"
return create_async_engine(asyncpg_test_url(uri), connect_args=build_asyncpg_connect_args(schema)), schema
async def _shape(engine) -> dict:
async with engine.connect() as conn:
def read(sync):
inspector = sa.inspect(sync)
tables = set(inspector.get_table_names())
if TABLE not in tables:
return {"tables": tables}
return {
"tables": tables,
"columns": {col["name"]: col for col in inspector.get_columns(TABLE)},
"pk": inspector.get_pk_constraint(TABLE),
}
return await conn.run_sync(read)
async def _orm_diff(engine) -> list:
"""Alembic's own drift check, restricted to the table this revision owns."""
def only_leases(obj, name, type_, reflected, compare_to):
if type_ == "table":
return name == TABLE
return getattr(getattr(obj, "table", None), "name", TABLE) == TABLE
async with engine.connect() as conn:
def diff(sync):
context = MigrationContext.configure(sync, opts={"include_object": only_leases, "compare_type": True, "compare_server_default": True})
return compare_metadata(context, Base.metadata)
return await conn.run_sync(diff)
async def _drop_schema(engine, schema):
if schema:
async with engine.begin() as conn:
await conn.execute(sa.text(f'DROP SCHEMA IF EXISTS "{schema}" CASCADE'))
@pytest.mark.parametrize("backend", ["sqlite", "postgres"])
async def test_0042_creates_the_table_matching_the_orm_and_downgrades_cleanly(tmp_path, backend):
engine, schema = _engine(tmp_path, backend)
cfg = bootstrap._get_alembic_config(engine, postgres_schema=schema or "")
try:
if schema:
async with engine.begin() as conn:
await conn.execute(sa.text(f'CREATE SCHEMA "{schema}"'))
await asyncio.to_thread(command.upgrade, cfg, PREVIOUS)
assert TABLE not in (await _shape(engine))["tables"]
await asyncio.to_thread(command.upgrade, cfg, REVISION)
shape = await _shape(engine)
assert set(shape["columns"]) == COLUMNS
assert shape["pk"]["constrained_columns"] == ["provider"]
assert shape["pk"]["name"] in ("pk_channel_leases", None) # SQLite does not report constraint names
assert all(column["nullable"] is False for column in shape["columns"].values())
# ``make migrate-rev`` would propose nothing: the revision matches the ORM model.
assert await _orm_diff(engine) == []
async with engine.begin() as conn:
await conn.execute(sa.insert(ChannelLeaseRow).values(provider="telegram", owner_id="host:worker", epoch=1, lease_expires_at=1_700_000_030.0, transport_running=True, updated_at=1_700_000_000.0))
with pytest.raises(sa.exc.IntegrityError):
async with engine.begin() as conn:
await conn.execute(sa.insert(ChannelLeaseRow).values(provider="telegram", owner_id="other", epoch=1, lease_expires_at=1.0, transport_running=False, updated_at=1.0))
await asyncio.to_thread(command.downgrade, cfg, PREVIOUS)
assert TABLE not in (await _shape(engine))["tables"]
await asyncio.to_thread(command.upgrade, cfg, REVISION)
assert TABLE in (await _shape(engine))["tables"]
finally:
await _drop_schema(engine, schema)
await engine.dispose()
@pytest.mark.parametrize("backend", ["sqlite", "postgres"])
async def test_0042_completes_after_create_all_and_downgrades_after_a_manual_drop(tmp_path, backend):
"""The table already exists (an interrupted earlier attempt): upgrade still lands, and vice versa."""
engine, schema = _engine(tmp_path, backend)
cfg = bootstrap._get_alembic_config(engine, postgres_schema=schema or "")
try:
if schema:
async with engine.begin() as conn:
await conn.execute(sa.text(f'CREATE SCHEMA "{schema}"'))
await asyncio.to_thread(command.upgrade, cfg, PREVIOUS)
async with engine.begin() as conn:
await conn.run_sync(Base.metadata.create_all, tables=[ChannelLeaseRow.__table__])
await asyncio.to_thread(command.upgrade, cfg, REVISION)
async with engine.connect() as conn:
assert (await conn.execute(sa.text("SELECT version_num FROM alembic_version"))).scalar_one() == REVISION
async with engine.begin() as conn:
await conn.execute(sa.text(f"DROP TABLE {TABLE}"))
await asyncio.to_thread(command.downgrade, cfg, PREVIOUS)
async with engine.connect() as conn:
assert (await conn.execute(sa.text("SELECT version_num FROM alembic_version"))).scalar_one() == PREVIOUS
finally:
await _drop_schema(engine, schema)
await engine.dispose()
async def test_bootstrap_provisions_the_table_on_an_empty_database(tmp_path):
engine = create_async_engine(f"sqlite+aiosqlite:///{tmp_path / 'bootstrap.db'}")
try:
await bootstrap.bootstrap_schema(engine, backend="sqlite")
await bootstrap.bootstrap_schema(engine, backend="sqlite")
assert set((await _shape(engine))["columns"]) == COLUMNS
async with engine.connect() as conn:
assert (await conn.execute(sa.text("SELECT version_num FROM alembic_version"))).scalar_one() == CURRENT_HEAD
finally:
await engine.dispose()