feat: replace NATS ingest with procrastinate Postgres queue (#183)
Re-architect document ingest from the shared NATS-glued document-processor to a per-tenant, in-process model owned by nextcloud-mcp-server (Deck #183). The MCP server now owns both sides of ingest: - Producer (api role): the scanner defers one job per changed document into the app's Postgres via procrastinate (queueing_lock dedup; no execution lock, so a crashed worker can't deadlock a doc — Qdrant upserts are idempotent). - Consumer (worker role): `nextcloud-mcp-server worker` drains the queue and runs the existing process_document pipeline; a periodic task reclaims jobs orphaned in `doing` by a crash. INGEST_QUEUE selects the transport (auto: postgres when DATABASE_URL is Postgres, else the in-process anyio queue for SQLite/dev). procrastinate manages its own tables (applied on a fresh DB at startup and by `db upgrade`). The vector-sync status surface reads job counts from Postgres in postgres mode. procrastinate + psycopg3 ship in the [postgres] extra; the app's own engine still uses asyncpg (driver unification is a follow-up handled in the rendered Helm chart). NATS JetStream, the Postgres-queue stub, the bus status subscriber, and nats-py are removed. BREAKING CHANGE: the external-NATS-ingest env vars are removed (INGEST_MODE, STATUS_BACKEND, INGEST_BUS_URL, INGEST_BUS_NUM_REPLICAS, FACT_EVENT_EMITTER). Use INGEST_QUEUE (memory|postgres) and the `worker` command instead. TENANT_ID is retained (no longer NATS-subject-charset-validated). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
This commit is contained in:
Chris Coutinho
co-authored by
Claude Opus 4.8
Claude Opus 4.8
parent
b91af923d2
commit
21b7922bac
@@ -0,0 +1,57 @@
|
||||
"""Unit tests for the shared ingest-status read model (Deck #183)."""
|
||||
|
||||
from types import SimpleNamespace
|
||||
from unittest.mock import AsyncMock
|
||||
|
||||
import pytest
|
||||
|
||||
from nextcloud_mcp_server.vector.ingest_status import get_ingest_pending
|
||||
|
||||
pytestmark = pytest.mark.unit
|
||||
|
||||
|
||||
class TestGetIngestPending:
|
||||
async def test_postgres_reads_job_counts(self):
|
||||
producer = AsyncMock()
|
||||
producer.job_counts.return_value = {"todo": 5, "doing": 2, "failed": 1}
|
||||
|
||||
result = await get_ingest_pending(
|
||||
task_producer=producer,
|
||||
document_receive_stream=None,
|
||||
ingest_queue="postgres",
|
||||
)
|
||||
assert result.pending == 7 # todo + doing
|
||||
assert result.job_counts == {"todo": 5, "doing": 2, "failed": 1}
|
||||
|
||||
async def test_postgres_degrades_to_zero_on_error(self):
|
||||
producer = AsyncMock()
|
||||
producer.job_counts.side_effect = RuntimeError("db down")
|
||||
|
||||
result = await get_ingest_pending(
|
||||
task_producer=producer,
|
||||
document_receive_stream=None,
|
||||
ingest_queue="postgres",
|
||||
)
|
||||
assert result.pending == 0
|
||||
assert result.job_counts == {}
|
||||
|
||||
async def test_memory_reads_stream_buffer(self):
|
||||
stream = SimpleNamespace(
|
||||
statistics=lambda: SimpleNamespace(current_buffer_used=3)
|
||||
)
|
||||
result = await get_ingest_pending(
|
||||
task_producer=None,
|
||||
document_receive_stream=stream,
|
||||
ingest_queue="memory",
|
||||
)
|
||||
assert result.pending == 3
|
||||
assert result.job_counts is None
|
||||
|
||||
async def test_memory_without_stream_is_zero(self):
|
||||
result = await get_ingest_pending(
|
||||
task_producer=None,
|
||||
document_receive_stream=None,
|
||||
ingest_queue="memory",
|
||||
)
|
||||
assert result.pending == 0
|
||||
assert result.job_counts is None
|
||||
@@ -1,155 +0,0 @@
|
||||
"""NATS ingest producer: DocumentTask → IngestMessage + dedup header (§3.4)."""
|
||||
|
||||
import hashlib
|
||||
import json
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
from nextcloud_mcp_server.canonical import canonical_json
|
||||
from nextcloud_mcp_server.vector.queue.factory import _transport_for
|
||||
from nextcloud_mcp_server.vector.queue.nats import (
|
||||
NatsTaskProducer,
|
||||
_modified_at_rfc3339,
|
||||
msg_id,
|
||||
warn_if_insecure_nats_url,
|
||||
)
|
||||
from nextcloud_mcp_server.vector.queue.postgres import PostgresTaskProducer
|
||||
from nextcloud_mcp_server.vector.scanner import DocumentTask
|
||||
|
||||
FIXTURE = Path(__file__).parents[2] / "fixtures" / "ingest_message_example.json"
|
||||
TENANT = "00000000-0000-0000-0000-000000000001"
|
||||
|
||||
|
||||
def _producer(mocker, tenant_id=TENANT):
|
||||
return NatsTaskProducer(
|
||||
nc=mocker.MagicMock(), js=mocker.AsyncMock(), tenant_id=tenant_id
|
||||
)
|
||||
|
||||
|
||||
def test_ingest_message_translation(mocker):
|
||||
p = _producer(mocker)
|
||||
task = DocumentTask(
|
||||
user_id="alice",
|
||||
doc_id="12345",
|
||||
doc_type="file",
|
||||
operation="index",
|
||||
modified_at=1700000000,
|
||||
file_path="/Documents/report.pdf",
|
||||
etag="etag-abc123",
|
||||
)
|
||||
msg = p.ingest_message(task)
|
||||
assert msg["tenant_id"] == TENANT # from settings, not the task
|
||||
assert msg["content_hash"] == "etag-abc123" # etag wins
|
||||
assert msg["user_id"] == "alice"
|
||||
assert msg["doc_type"] == "file"
|
||||
assert msg["operation"] == "index"
|
||||
assert msg["file_path"] == "/Documents/report.pdf"
|
||||
|
||||
|
||||
def test_content_hash_falls_back_to_modified_at(mocker):
|
||||
p = _producer(mocker)
|
||||
task = DocumentTask(
|
||||
user_id="u", doc_id="d", doc_type="note", operation="delete", modified_at=0
|
||||
)
|
||||
assert p.ingest_message(task)["content_hash"] == "0"
|
||||
|
||||
|
||||
async def test_send_publishes_with_dedup_header(mocker):
|
||||
p = _producer(mocker)
|
||||
task = DocumentTask(
|
||||
user_id="alice",
|
||||
doc_id="12345",
|
||||
doc_type="file",
|
||||
operation="index",
|
||||
modified_at=1700000000,
|
||||
etag="e",
|
||||
)
|
||||
await p.send(task)
|
||||
p._js.publish.assert_awaited_once()
|
||||
args = p._js.publish.await_args.args
|
||||
kwargs = p._js.publish.await_args.kwargs
|
||||
assert args[0] == f"mcp.ingest.requested.{TENANT}"
|
||||
expected_mid = msg_id(TENANT, "12345", _modified_at_rfc3339(1700000000))
|
||||
assert kwargs["headers"]["Nats-Msg-Id"] == expected_mid
|
||||
assert json.loads(args[1])["doc_id"] == "12345"
|
||||
|
||||
|
||||
def test_msg_id_known_vector():
|
||||
mid = msg_id("t", "d", "2026-01-01T00:00:00+00:00")
|
||||
expected = hashlib.sha256(
|
||||
canonical_json(
|
||||
{
|
||||
"tenant_id": "t",
|
||||
"doc_id": "d",
|
||||
"modified_at": "2026-01-01T00:00:00+00:00",
|
||||
}
|
||||
)
|
||||
).hexdigest()
|
||||
assert mid == expected
|
||||
|
||||
|
||||
def test_publisher_matches_shared_fixture(mocker):
|
||||
# The same fixture is validated as an IngestMessage in the processor repo.
|
||||
# Here we assert the publisher emits exactly the fixture's key set + stable
|
||||
# field values (modified_at format is allowed to differ — epoch→ISO).
|
||||
fixture = json.loads(FIXTURE.read_text(encoding="utf-8"))
|
||||
p = _producer(mocker, tenant_id=fixture["tenant_id"])
|
||||
task = DocumentTask(
|
||||
user_id=fixture["user_id"],
|
||||
doc_id=fixture["doc_id"],
|
||||
doc_type=fixture["doc_type"],
|
||||
operation=fixture["operation"],
|
||||
modified_at=1764201600,
|
||||
file_path=fixture["file_path"],
|
||||
etag=fixture["content_hash"],
|
||||
)
|
||||
msg = p.ingest_message(task)
|
||||
assert set(msg.keys()) == set(fixture.keys())
|
||||
for key in (
|
||||
"tenant_id",
|
||||
"doc_id",
|
||||
"content_hash",
|
||||
"doc_type",
|
||||
"operation",
|
||||
"user_id",
|
||||
"file_path",
|
||||
):
|
||||
assert msg[key] == fixture[key]
|
||||
assert msg["modified_at"] # non-empty ISO timestamp
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"url,expected",
|
||||
[
|
||||
("nats://nats:4222", "nats"),
|
||||
("postgres://h/db", "postgres"),
|
||||
("postgresql://h/db", "postgres"),
|
||||
("https://elsewhere", "nats"),
|
||||
],
|
||||
)
|
||||
def test_transport_for(url, expected):
|
||||
assert _transport_for(url) == expected
|
||||
|
||||
|
||||
async def test_postgres_producer_is_a_seam():
|
||||
with pytest.raises(NotImplementedError, match="documented seam"):
|
||||
await PostgresTaskProducer.connect(object())
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"url,should_warn",
|
||||
[
|
||||
("nats://nats:4222", True),
|
||||
("ws://nats:8080", True),
|
||||
("tls://nats:4222", False),
|
||||
("wss://nats:8080", False),
|
||||
],
|
||||
)
|
||||
def test_warn_if_insecure_nats_url(url, should_warn, caplog):
|
||||
import logging
|
||||
|
||||
with caplog.at_level(logging.WARNING):
|
||||
warn_if_insecure_nats_url(url)
|
||||
warned = any("unencrypted transport" in r.getMessage() for r in caplog.records)
|
||||
assert warned is should_warn
|
||||
@@ -0,0 +1,191 @@
|
||||
"""Unit tests for the procrastinate ingest producer + task (Deck #183).
|
||||
|
||||
Uses procrastinate's in-memory connector so no live Postgres is required.
|
||||
"""
|
||||
|
||||
from unittest.mock import AsyncMock
|
||||
|
||||
import pytest
|
||||
from procrastinate import testing
|
||||
|
||||
import nextcloud_mcp_server.vector.queue.procrastinate as pq
|
||||
from nextcloud_mcp_server.vector.scanner import DocumentTask
|
||||
|
||||
pytestmark = pytest.mark.unit
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def app():
|
||||
"""An App bound to the in-memory connector with the ingest tasks."""
|
||||
return pq.build_app(testing.InMemoryConnector())
|
||||
|
||||
|
||||
def _task(doc_id="42", doc_type="note", operation="index"):
|
||||
return DocumentTask(
|
||||
user_id="alice",
|
||||
doc_id=doc_id,
|
||||
doc_type=doc_type,
|
||||
operation=operation,
|
||||
modified_at=100,
|
||||
etag="etag-abc",
|
||||
)
|
||||
|
||||
|
||||
class TestProcrastinateTaskProducer:
|
||||
async def test_send_defers_with_correct_job_shape(self, app):
|
||||
async with app.open_async():
|
||||
producer = pq.ProcrastinateTaskProducer(app)
|
||||
await producer.send(_task())
|
||||
|
||||
jobs = list(app.connector.jobs.values())
|
||||
assert len(jobs) == 1
|
||||
job = jobs[0]
|
||||
assert job["task_name"] == pq.INGEST_TASK_NAME
|
||||
assert job["queue_name"] == pq.INGEST_QUEUE_NAME
|
||||
assert job["queueing_lock"] == "alice:note:42"
|
||||
assert job["lock"] is None # no execution lock (crash-deadlock guard)
|
||||
assert job["args"]["doc_id"] == "42"
|
||||
assert job["args"]["etag"] == "etag-abc"
|
||||
|
||||
async def test_duplicate_send_is_deduped(self, app):
|
||||
async with app.open_async():
|
||||
producer = pq.ProcrastinateTaskProducer(app)
|
||||
await producer.send(_task())
|
||||
# Same doc again → AlreadyEnqueued, swallowed; still one job.
|
||||
await producer.send(_task())
|
||||
assert len(app.connector.jobs) == 1
|
||||
|
||||
async def test_distinct_docs_create_separate_jobs(self, app):
|
||||
async with app.open_async():
|
||||
producer = pq.ProcrastinateTaskProducer(app)
|
||||
await producer.send(_task(doc_id="1"))
|
||||
await producer.send(_task(doc_id="2"))
|
||||
assert len(app.connector.jobs) == 2
|
||||
|
||||
def test_clone_returns_self(self, app):
|
||||
producer = pq.ProcrastinateTaskProducer(app)
|
||||
assert producer.clone() is producer
|
||||
|
||||
|
||||
class TestProcessDocumentTask:
|
||||
async def test_runs_pipeline_and_closes_client(self, monkeypatch):
|
||||
captured = {}
|
||||
|
||||
fake_client = AsyncMock()
|
||||
|
||||
async def fake_resolve(user_id):
|
||||
captured["user_id"] = user_id
|
||||
return fake_client
|
||||
|
||||
async def fake_process(task, nc_client, *, max_retries):
|
||||
captured["task"] = task
|
||||
captured["nc_client"] = nc_client
|
||||
captured["max_retries"] = max_retries
|
||||
|
||||
monkeypatch.setattr(pq, "_resolve_client", fake_resolve)
|
||||
monkeypatch.setattr(
|
||||
"nextcloud_mcp_server.vector.processor.process_document", fake_process
|
||||
)
|
||||
|
||||
# Calling the Task runs its wrapped function in-process.
|
||||
await pq.process_document_task(
|
||||
user_id="alice",
|
||||
doc_id="42",
|
||||
doc_type="note",
|
||||
operation="index",
|
||||
modified_at=100,
|
||||
etag="e1",
|
||||
)
|
||||
|
||||
assert captured["user_id"] == "alice"
|
||||
assert isinstance(captured["task"], DocumentTask)
|
||||
assert captured["task"].doc_id == "42"
|
||||
assert captured["task"].etag == "e1"
|
||||
# Worker disables the in-process retry loop; durable retry is the queue's.
|
||||
assert captured["max_retries"] == 1
|
||||
fake_client.close.assert_awaited_once()
|
||||
|
||||
async def test_skips_on_missing_credentials(self, monkeypatch):
|
||||
from nextcloud_mcp_server.vector.oauth_sync import NotProvisionedError
|
||||
|
||||
async def fake_resolve(user_id):
|
||||
raise NotProvisionedError("no app password")
|
||||
|
||||
called = False
|
||||
|
||||
async def fake_process(*args, **kwargs):
|
||||
nonlocal called
|
||||
called = True
|
||||
|
||||
monkeypatch.setattr(pq, "_resolve_client", fake_resolve)
|
||||
monkeypatch.setattr(
|
||||
"nextcloud_mcp_server.vector.processor.process_document", fake_process
|
||||
)
|
||||
|
||||
# Returns cleanly (job succeeds as a no-op); pipeline never runs.
|
||||
await pq.process_document_task(
|
||||
user_id="ghost",
|
||||
doc_id="9",
|
||||
doc_type="note",
|
||||
operation="index",
|
||||
modified_at=0,
|
||||
)
|
||||
assert called is False
|
||||
|
||||
|
||||
class TestReclaimStalledJobs:
|
||||
async def test_reclaims_each_stalled_job(self):
|
||||
from datetime import datetime
|
||||
|
||||
retried: list[int] = []
|
||||
|
||||
class Job:
|
||||
def __init__(self, id):
|
||||
self.id = id
|
||||
|
||||
class FakeManager:
|
||||
async def get_stalled_jobs(self, queue=None, seconds_since_heartbeat=0):
|
||||
assert queue == pq.INGEST_QUEUE_NAME
|
||||
return [Job(1), Job(2), Job(None)] # None id is skipped
|
||||
|
||||
async def retry_job_by_id_async(self, job_id, retry_at):
|
||||
assert isinstance(retry_at, datetime)
|
||||
retried.append(job_id)
|
||||
|
||||
class FakeApp:
|
||||
job_manager = FakeManager()
|
||||
|
||||
class Ctx:
|
||||
app = FakeApp()
|
||||
|
||||
await pq.reclaim_stalled_ingest_jobs(Ctx(), timestamp=0)
|
||||
assert retried == [1, 2]
|
||||
|
||||
|
||||
class TestGetIngestJobCounts:
|
||||
async def test_aggregates_stats_rows(self):
|
||||
class FakeManager:
|
||||
async def list_queues_async(self, queue=None):
|
||||
assert queue == pq.INGEST_QUEUE_NAME
|
||||
# procrastinate flattens per-status stats into top-level keys.
|
||||
return [
|
||||
{
|
||||
"name": "ingest",
|
||||
"jobs_count": 6,
|
||||
"todo": 3,
|
||||
"doing": 1,
|
||||
"succeeded": 0,
|
||||
"failed": 2,
|
||||
"cancelled": 0,
|
||||
"aborted": 0,
|
||||
}
|
||||
]
|
||||
|
||||
class FakeApp:
|
||||
job_manager = FakeManager()
|
||||
|
||||
counts = await pq.get_ingest_job_counts(FakeApp())
|
||||
assert counts["todo"] == 3
|
||||
assert counts["doing"] == 1
|
||||
assert counts["failed"] == 2
|
||||
assert counts["succeeded"] == 0
|
||||
@@ -1,167 +0,0 @@
|
||||
"""StatusStore + NATS status message handling (design §10.1, STATUS_BACKEND=bus)."""
|
||||
|
||||
import json
|
||||
|
||||
from nextcloud_mcp_server.vector.queue.status import (
|
||||
NatsStatusSubscriber,
|
||||
StatusStore,
|
||||
state_from_subject,
|
||||
)
|
||||
|
||||
|
||||
def test_store_records_and_counts():
|
||||
store = StatusStore()
|
||||
store.record("d1", "ready", content_hash="h1")
|
||||
store.record("d2", "failed")
|
||||
store.record("d1", "ready", content_hash="h1") # idempotent overwrite
|
||||
assert len(store) == 2
|
||||
assert store.counts() == {"ready": 1, "failed": 1}
|
||||
assert store.get("d1")["content_hash"] == "h1"
|
||||
|
||||
|
||||
def test_store_is_bounded_lru():
|
||||
store = StatusStore(max_size=2)
|
||||
store.record("d1", "ready")
|
||||
store.record("d2", "ready")
|
||||
store.record("d3", "ready") # evicts d1
|
||||
assert len(store) == 2
|
||||
assert store.get("d1") is None
|
||||
assert store.get("d3") is not None
|
||||
|
||||
|
||||
def test_state_from_subject():
|
||||
assert state_from_subject("mcp.document.ready.tenant-1") == "ready"
|
||||
assert state_from_subject("mcp.document.failed.tenant-1") == "failed"
|
||||
assert state_from_subject("mcp.document.reparsed.tenant-1") == "reparsed"
|
||||
assert state_from_subject("mcp.document.bogus.tenant-1") is None
|
||||
assert state_from_subject("mcp.ingest.requested.tenant-1") is None
|
||||
|
||||
|
||||
def test_handle_message_records_state():
|
||||
store = StatusStore()
|
||||
events = []
|
||||
sub = NatsStatusSubscriber(
|
||||
nc=None,
|
||||
js=None,
|
||||
tenant_id="t1",
|
||||
store=store,
|
||||
on_event=lambda d, s: events.append((d, s)),
|
||||
)
|
||||
payload = json.dumps(
|
||||
{
|
||||
"tenant_id": "t1",
|
||||
"doc_id": "doc-9",
|
||||
"content_hash": "abc",
|
||||
"transitioned_at": "2026-05-27T00:00:00Z",
|
||||
}
|
||||
).encode()
|
||||
sub.handle_message("mcp.document.ready.t1", payload)
|
||||
entry = store.get("doc-9")
|
||||
assert entry["state"] == "ready"
|
||||
assert entry["content_hash"] == "abc"
|
||||
assert events == [("doc-9", "ready")]
|
||||
|
||||
|
||||
def test_handle_message_ignores_bad_payload_and_subject():
|
||||
store = StatusStore()
|
||||
sub = NatsStatusSubscriber(nc=None, js=None, tenant_id="t1", store=store)
|
||||
sub.handle_message("mcp.document.ready.t1", b"not json")
|
||||
sub.handle_message("mcp.ingest.requested.t1", b'{"doc_id":"x"}')
|
||||
assert len(store) == 0
|
||||
|
||||
|
||||
async def test_run_signals_started_then_retries_subscribe(mocker, monkeypatch):
|
||||
"""run() signals started before subscribing, retries a failed subscribe,
|
||||
and consumes messages once subscribed."""
|
||||
import anyio
|
||||
|
||||
# Make backoff sleeps instant so the retry path doesn't stall the test.
|
||||
async def _no_sleep(*_a, **_k):
|
||||
return None
|
||||
|
||||
monkeypatch.setattr(anyio, "sleep", _no_sleep)
|
||||
|
||||
store = StatusStore()
|
||||
js = mocker.AsyncMock()
|
||||
|
||||
# First subscribe attempt fails (broker not ready), second succeeds.
|
||||
fake_sub = mocker.AsyncMock()
|
||||
js.pull_subscribe.side_effect = [ConnectionError("broker not ready"), fake_sub]
|
||||
|
||||
shutdown = anyio.Event()
|
||||
msg = mocker.Mock()
|
||||
msg.subject = "mcp.document.ready.t1"
|
||||
msg.data = json.dumps({"doc_id": "d1", "content_hash": "h1"}).encode()
|
||||
msg.ack = mocker.AsyncMock()
|
||||
|
||||
fetches = {"n": 0}
|
||||
|
||||
async def _fetch(*_a, **_k):
|
||||
fetches["n"] += 1
|
||||
if fetches["n"] == 1:
|
||||
return [msg]
|
||||
shutdown.set() # stop the loop after the first batch is handled
|
||||
return []
|
||||
|
||||
fake_sub.fetch.side_effect = _fetch
|
||||
|
||||
task_status = mocker.Mock()
|
||||
subscriber = NatsStatusSubscriber(
|
||||
nc=mocker.AsyncMock(), js=js, tenant_id="t1", store=store
|
||||
)
|
||||
|
||||
await subscriber.run(shutdown, task_status=task_status)
|
||||
|
||||
# started() fires before any subscribe attempt and exactly once.
|
||||
task_status.started.assert_called_once()
|
||||
# The failed first subscribe was retried (two attempts total).
|
||||
assert js.pull_subscribe.call_count == 2
|
||||
# The message from the successful subscription was recorded + acked.
|
||||
assert store.get("d1") == {
|
||||
"state": "ready",
|
||||
"content_hash": "h1",
|
||||
"transitioned_at": None,
|
||||
}
|
||||
msg.ack.assert_awaited_once()
|
||||
|
||||
|
||||
async def test_run_resubscribes_after_fetch_error(mocker, monkeypatch):
|
||||
"""A non-timeout fetch error drops the subscription and re-subscribes."""
|
||||
import anyio
|
||||
import nats.errors
|
||||
|
||||
async def _no_sleep(*_a, **_k):
|
||||
return None
|
||||
|
||||
monkeypatch.setattr(anyio, "sleep", _no_sleep)
|
||||
|
||||
store = StatusStore()
|
||||
js = mocker.AsyncMock()
|
||||
first_sub = mocker.AsyncMock()
|
||||
second_sub = mocker.AsyncMock()
|
||||
js.pull_subscribe.side_effect = [first_sub, second_sub]
|
||||
|
||||
shutdown = anyio.Event()
|
||||
|
||||
# first_sub.fetch raises a real broker error → re-subscribe.
|
||||
first_sub.fetch.side_effect = ConnectionResetError("broker dropped")
|
||||
|
||||
# second_sub.fetch idles once (timeout) then stops the loop.
|
||||
fetches = {"n": 0}
|
||||
|
||||
async def _second_fetch(*_a, **_k):
|
||||
fetches["n"] += 1
|
||||
if fetches["n"] == 1:
|
||||
raise nats.errors.TimeoutError
|
||||
shutdown.set()
|
||||
return []
|
||||
|
||||
second_sub.fetch.side_effect = _second_fetch
|
||||
|
||||
subscriber = NatsStatusSubscriber(
|
||||
nc=mocker.AsyncMock(), js=js, tenant_id="t1", store=store
|
||||
)
|
||||
await subscriber.run(shutdown)
|
||||
|
||||
# Re-subscribed after the fetch error (two subscriptions used).
|
||||
assert js.pull_subscribe.call_count == 2
|
||||
Reference in New Issue
Block a user