Skip to content

Local UI to run and train LLMs and diffusion models. Supports GGUF, MLX, Qwen3.8, DeepSeek-V4.1, MiniMax-H3, Gemma 4, FLUX and more.

4.1 KB
Raw Blame
# SPDX-License-Identifier: AGPL-3.0-only
# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0

"""The SSE cursor starts at clear_logs()'s run-start snapshot, so early export lines are not lost."""

from __future__ import annotations

import sys
import types
from pathlib import Path

import pytest


_BACKEND_DIR = Path(__file__).resolve().parent.parent
if str(_BACKEND_DIR) not in sys.path:
    sys.path.insert(0, str(_BACKEND_DIR))

# stub orchestrator.py's heavy top-level imports so it loads without the venv
_loggers_stub = types.ModuleType("loggers")
_loggers_stub.get_logger = lambda name: __import__("logging").getLogger(name)
sys.modules.setdefault("loggers", _loggers_stub)

sys.modules.setdefault("structlog", types.ModuleType("structlog"))

_utils_pkg = types.ModuleType("utils")
_utils_pkg.__path__ = []
_utils_paths_stub = types.ModuleType("utils.paths")
_utils_paths_stub.outputs_root = lambda: Path("/tmp")
sys.modules.setdefault("utils", _utils_pkg)
sys.modules.setdefault("utils.paths", _utils_paths_stub)


@pytest.fixture
def orchestrator():
    """Fresh ExportOrchestrator with only the log-buffer state exercised."""
    from core.export.orchestrator import ExportOrchestrator
    return ExportOrchestrator()


def _append(
    orch,
    line: str,
    stream: str = "stdout",
) -> None:
    """Shortcut for simulating a worker log message."""
    orch._append_log({"type": "log", "stream": stream, "line": line, "ts": 0.0})


def test_run_start_seq_is_zero_before_any_logs(orchestrator) -> None:
    """run_start_seq starts at 0, so a first SSE reads every line from seq 1 onward."""
    assert orchestrator.get_run_start_seq() == 0


def test_clear_logs_snapshots_current_seq(orchestrator) -> None:
    """clear_logs() snapshots _log_seq before clearing, so the next SSE cursor anchors there."""
    _append(orchestrator, "old run line 1")
    _append(orchestrator, "old run line 2")
    _append(orchestrator, "old run line 3")
    assert orchestrator.get_current_log_seq() == 3

    orchestrator.clear_logs()

    assert orchestrator.get_run_start_seq() == 3
    assert orchestrator.get_current_log_seq() == 3


def test_sse_default_cursor_catches_all_current_run_lines(orchestrator) -> None:
    """POST-then-SSE race: lines emitted right after clear_logs() must reach a later SSE, so
    get_run_start_seq() is the default cursor."""
    _append(orchestrator, "previous run line A")
    _append(orchestrator, "previous run line B")

    orchestrator.clear_logs()
    run_start = orchestrator.get_run_start_seq()

    # worker emits early lines BEFORE the SSE connects
    _append(orchestrator, "Importing Unsloth...")
    _append(orchestrator, "Loading checkpoint: /foo/bar")
    _append(orchestrator, "Starting export...")

    entries, new_cursor = orchestrator.get_logs_since(run_start)

    lines = [e["line"] for e in entries]
    assert lines == [
        "Importing Unsloth...",
        "Loading checkpoint: /foo/bar",
        "Starting export...",
    ]
    assert new_cursor == entries[-1]["seq"]


def test_sse_default_cursor_excludes_previous_run(orchestrator) -> None:
    """After clear_logs(), previous-run lines must not leak into the new run's SSE stream."""
    _append(orchestrator, "previous run line 1")
    _append(orchestrator, "previous run line 2")
    _append(orchestrator, "previous run line 3")
    assert orchestrator.get_current_log_seq() == 3

    orchestrator.clear_logs()
    run_start = orchestrator.get_run_start_seq()

    _append(orchestrator, "new run line")

    entries, _ = orchestrator.get_logs_since(run_start)
    assert [e["line"] for e in entries] == ["new run line"]


def test_clear_logs_twice_advances_run_start(orchestrator) -> None:
    """Each clear_logs() re-anchors run_start to the current seq as a fresh low-water mark."""
    _append(orchestrator, "run 1 line a")
    _append(orchestrator, "run 1 line b")

    orchestrator.clear_logs()
    assert orchestrator.get_run_start_seq() == 2

    _append(orchestrator, "run 2 line a")
    _append(orchestrator, "run 2 line b")
    _append(orchestrator, "run 2 line c")

    orchestrator.clear_logs()
    assert orchestrator.get_run_start_seq() == 5