hermes-webui/tests/test_issue4755_profile_default_workspace.py

"""Behavior coverage for #4755 profile default workspace precedence."""

from __future__ import annotations

import json
import shutil
import subprocess
import textwrap
from pathlib import Path

import pytest

ROOT = Path(__file__).resolve().parents[1]
SESSIONS_JS = ROOT / "static" / "sessions.js"
PANELS_JS = ROOT / "static" / "panels.js"
NODE = shutil.which("node")

node_test = pytest.mark.skipif(NODE is None, reason="node not on PATH")


def _extract_async_function(source: str, name: str) -> str:
    marker = f"async function {name}("
    start = source.find(marker)
    assert start >= 0, f"{name}() function must exist"
    brace = source.find("{", source.find(")", start))
    assert brace > start, f"{name}() function body must start"
    depth = 0
    in_string = None
    escaped = False
    in_line_comment = False
    in_block_comment = False
    for idx in range(brace, len(source)):
        ch = source[idx]
        nxt = source[idx + 1] if idx + 1 < len(source) else ""
        if in_line_comment:
            if ch == "\n":
                in_line_comment = False
            continue
        if in_block_comment:
            if ch == "*" and nxt == "/":
                in_block_comment = False
            continue
        if in_string:
            if escaped:
                escaped = False
            elif ch == "\\":
                escaped = True
            elif ch == in_string:
                in_string = None
            continue
        if ch == "/" and nxt == "/":
            in_line_comment = True
            continue
        if ch == "/" and nxt == "*":
            in_block_comment = True
            continue
        if ch in ("'", '"', "`"):
            in_string = ch
            continue
        if ch == "{":
            depth += 1
        elif ch == "}":
            depth -= 1
            if depth == 0:
                return source[start : idx + 1]
    raise AssertionError(f"could not extract {name}()")


def _run_node(script: str) -> dict:
    result = subprocess.run(
        [NODE, "-e", script],
        cwd=ROOT,
        text=True,
        capture_output=True,
        timeout=30,
        check=False,
    )
    assert result.returncode == 0, result.stderr or result.stdout
    return json.loads(result.stdout)


def _new_session_driver(session_workspace: str, default_workspace: str, switch_workspace: str | None) -> str:
    new_session = _extract_async_function(SESSIONS_JS.read_text(encoding="utf-8"), "newSession")
    return textwrap.dedent(
        f"""
        let captured=null;
        var _newSessionInFlight=null;
        var _messagesTruncated=false;
        var _oldestIdx=0;
        var _activeProject=null;
        var NO_PROJECT_FILTER='__all__';
        var _sessionSourceFilter='webui';
        var S={{
          session:{{session_id:'previous-session',workspace:{json.dumps(session_workspace)}}},
          _profileDefaultWorkspace:{json.dumps(default_workspace)},
          _profileSwitchWorkspace:{json.dumps(switch_workspace)},
          activeProfile:'default',
          toolCalls:[],
        }};
        global.window={{}};
        global.document={{createElement:()=>({{dataset:{{}},appendChild:()=>{{}}}})}};
        global.localStorage={{setItem:()=>{{}}}};
        function $(id){{return null;}}
        function _newSessionPendingText(){{return 'Creating';}}
        function _setNewSessionPending(){{}}
        function updateQueueBadge(){{}}
        function clearLiveToolCards(){{}}
        function api(path,opts){{
          captured={{path,body:JSON.parse(opts.body)}};
          return Promise.resolve({{session:{{session_id:'new-session',messages:[],workspace:captured.body.workspace}}}});
        }}
        function _rememberNewChatDraftSession(){{}}
        function _setActiveSessionUrl(){{}}
        function _setSessionViewedCount(){{}}
        function updateSendBtn(){{}}
        function setStatus(){{}}
        function setComposerStatus(){{}}
        function syncTopbar(){{}}
        function renderMessages(){{}}
        function loadDir(){{return Promise.resolve();}}
        {new_session}
        newSession().then(()=>{{
          process.stdout.write(JSON.stringify({{
            captured,
            switchWorkspace:S._profileSwitchWorkspace,
            profileDefaultWorkspace:S._profileDefaultWorkspace,
          }}));
        }}).catch(err=>{{
          console.error(err && err.stack || err);
          process.exit(1);
        }});
        """
    )


@node_test
def test_new_session_prefers_current_session_workspace_over_profile_default():
    """Deliberate divergence from the precedence introduced in #4755.

    #4755 made the "profile default" win over the current conversation's workspace.
    That precedence assumes the profile default is a stable, configured value. It is
    not, for a structural reason:

    ``api/workspace.py::get_profile_default_workspace()`` reads ``last_workspace.txt``
    BEFORE the configured value, and for the ``default`` profile that file is the
    GLOBAL one. ``set_last_workspace()`` rewrites it on every ``/api/chat/start`` and
    ``/api/session/update`` from ANY conversation.

    So ``S._profileDefaultWorkspace`` — hydrated from ``/api/profile/active`` — is not a
    configured default: it is a volatile shared pointer. "profile default wins over the
    current conversation" therefore degrades into "the workspace last used by ANOTHER
    conversation wins over the conversation I am actually in". With several
    conversations open on different workspaces, opening a new chat from conversation A
    created it on conversation B's workspace.

    Precedence used here: one-shot profile switch -> current conversation -> profile
    default. The profile default remains the blank-page fallback (#804/#5169) and is
    never consumed (#823).

    MAINTAINER NOTE: this intentionally diverges from #4755 and will conflict if that
    precedence is restored. Please do not "fix" it by reinstating the previous order
    without first addressing the volatility of ``get_profile_default_workspace()``.
    """
    payload = _run_node(_new_session_driver(
        session_workspace="/current-workspace",
        default_workspace="/profile-default",
        switch_workspace=None,
    ))

    assert payload["captured"]["path"] == "/api/session/new"
    assert payload["captured"]["body"]["workspace"] == "/current-workspace"
    assert payload["captured"]["body"]["prev_session_id"] == "previous-session"
    assert payload["captured"]["body"]["workspace_inherited_from_prev_session"] is True
    assert payload["profileDefaultWorkspace"] == "/profile-default"


@node_test
def test_new_session_blank_page_falls_back_to_profile_default():
    """Sans conversation chargée, le défaut de profil reste le repli (#804/#5169)."""
    driver = _new_session_driver(
        session_workspace="/current-workspace",
        default_workspace="/profile-default",
        switch_workspace=None,
    ).replace(
        "session:{session_id:'previous-session',workspace:\"/current-workspace\"},",
        "session:null,",
    )
    payload = _run_node(driver)

    assert payload["captured"]["body"]["workspace"] == "/profile-default"
    assert "workspace_inherited_from_prev_session" not in payload["captured"]["body"]
    assert payload["profileDefaultWorkspace"] == "/profile-default"



@node_test
def test_new_session_one_shot_switch_workspace_still_wins_and_clears():
    payload = _run_node(_new_session_driver(
        session_workspace="/current-workspace",
        default_workspace="/profile-default",
        switch_workspace="/explicit-switch",
    ))

    assert payload["captured"]["body"]["workspace"] == "/explicit-switch"
    assert "workspace_inherited_from_prev_session" not in payload["captured"]["body"]
    assert payload["switchWorkspace"] is None
    assert payload["profileDefaultWorkspace"] == "/profile-default"


@node_test
def test_parallel_conversations_each_inherit_their_own_workspace():
    first = _run_node(_new_session_driver(
        session_workspace="/workspace-a",
        default_workspace="/shared-profile-pointer",
        switch_workspace=None,
    ))
    second = _run_node(_new_session_driver(
        session_workspace="/workspace-b",
        default_workspace="/shared-profile-pointer",
        switch_workspace=None,
    ))

    assert first["captured"]["body"]["workspace"] == "/workspace-a"
    assert second["captured"]["body"]["workspace"] == "/workspace-b"
    assert first["captured"]["body"]["workspace_inherited_from_prev_session"] is True
    assert second["captured"]["body"]["workspace_inherited_from_prev_session"] is True


@node_test
def test_busy_workspace_switch_returns_before_session_update():
    switch_to_workspace = _extract_async_function(PANELS_JS.read_text(encoding="utf-8"), "switchToWorkspace")
    script = textwrap.dedent(
        f"""
        const calls=[];
        var S={{busy:true,session:{{session_id:'session-1',workspace:'/old',model:'gpt-5',model_provider:null}}}};
        function t(key){{return key;}}
        function showToast(message){{calls.push(['toast',message]);}}
        function api(path,opts){{calls.push(['api',path]);return Promise.resolve({{}});}}
        {switch_to_workspace}
        switchToWorkspace('/new','New').then(()=>{{
          process.stdout.write(JSON.stringify({{calls}}));
        }}).catch(err=>{{
          console.error(err && err.stack || err);
          process.exit(1);
        }});
        """
    )
    payload = _run_node(script)

    assert payload["calls"] == [["toast", "workspace_busy_switch"]]