Skip to content

Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.

3.2 KB
Raw Blame
# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
# SPDX-License-Identifier: AGPL-3.0
"""Tests for QueueObserver health semantics."""

from openviking.storage.observers.queue_observer import QueueObserver
from openviking.storage.queuefs.named_queue import QueueStatus


class _FakeQueueManager:
    SEMANTIC = "Semantic"

    def __init__(self, statuses: dict[str, QueueStatus]):
        self._statuses = statuses
        self._queues = {}

    async def check_status(self) -> dict[str, QueueStatus]:
        return self._statuses


def test_historical_queue_errors_do_not_make_drained_queue_unhealthy() -> None:
    observer = QueueObserver(
        _FakeQueueManager(
            {
                "Semantic": QueueStatus(
                    pending=0,
                    in_progress=0,
                    processed=69,
                    requeue_count=1,
                    error_count=1,
                )
            }
        )
    )

    assert observer.has_errors() is False
    assert observer.is_healthy() is True

    table = observer.get_status_table()
    assert "Semantic" in table
    assert "Warnings:" not in table


def test_queue_errors_make_pending_queue_unhealthy() -> None:
    observer = QueueObserver(
        _FakeQueueManager(
            {
                "Semantic": QueueStatus(
                    pending=1,
                    in_progress=0,
                    processed=69,
                    error_count=1,
                )
            }
        )
    )

    assert observer.has_errors() is True
    assert observer.is_healthy() is False

    table = observer.get_status_table()
    assert "Warnings:" not in table


def test_queue_errors_make_in_progress_queue_unhealthy() -> None:
    observer = QueueObserver(
        _FakeQueueManager(
            {
                "Semantic": QueueStatus(
                    pending=0,
                    in_progress=1,
                    processed=69,
                    error_count=1,
                )
            }
        )
    )

    assert observer.has_errors() is True
    assert observer.is_healthy() is False


class _TreeStats:
    total_nodes = 9
    pending_nodes = 1
    in_progress_nodes = 0
    done_nodes = 8


class _FakeSemanticHandler:
    @staticmethod
    def get_tree_stats():
        return _TreeStats()


class _FakeSemanticQueue:
    _dequeue_handler = _FakeSemanticHandler()


def test_status_json_summary_matches_table_totals() -> None:
    queue_manager = _FakeQueueManager(
        {
            "Semantic": QueueStatus(
                pending=0,
                in_progress=0,
                processed=2,
                error_count=0,
            )
        }
    )
    queue_manager._queues = {queue_manager.SEMANTIC: _FakeSemanticQueue()}
    observer = QueueObserver(queue_manager)

    status = observer.get_status_json()

    assert status["queues"][-1] == {
        "queue": "Semantic-Nodes",
        "pending": 1,
        "in_progress": 0,
        "processed": 8,
        "requeued": 0,
        "errors": 0,
        "total": 9,
    }
    assert status["summary"] == {
        "pending": 0,
        "in_progress": 0,
        "processed": 2,
        "requeued": 0,
        "errors": 0,
        "total": 2,
    }