pyssh-client/tests/test_workspace.py

"""Workspaces : capture de l'etat des onglets (avec splits), sauvegarde/
rechargement JSON, restauration (y compris partielle si une session referencee
a ete supprimee depuis), et parametre de restauration automatique au demarrage.

SSHConnection.start()/LocalTerminalConnection.start() sont neutralisees (pas de
connexion reelle necessaire). app.app_settings.SETTINGS_FILE est redirige vers
un fichier temporaire pour ne jamais toucher les vrais reglages de l'utilisateur
(restore() met a jour last_workspace_id a chaque restauration)."""
import sys, pathlib
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent.parent))

import itertools
import tempfile
from pathlib import Path
from unittest.mock import patch

from PySide6.QtWidgets import QApplication, QWidget

from app.session_manager import Session, SessionStore
from app.key_manager import KeyManager
from app.ssh_connection import SSHConnection
from app.local_terminal import LocalTerminalConnection
from app.controllers.broadcast_manager import BroadcastManager
from app.controllers.connection_controller import ConnectionController
from app.controllers.workspace_manager import (
    WorkspaceManager, SETTING_RESTORE_ON_STARTUP, SETTING_LAST_WORKSPACE_ID,
)
from app.workspace import WorkspaceStore, ITEM_SESSION_SSH, ITEM_LOCAL_SHELL
from app.ui.split_pane import LAYOUT_2V
import app.app_settings as app_settings

app = QApplication.instance() or QApplication([])

tmp = Path(tempfile.mkdtemp())
_counter = itertools.count()

no_ssh_thread = patch.object(SSHConnection, "start", lambda self: None)
no_local_thread = patch.object(LocalTerminalConnection, "start", lambda self: None)
settings_redirect = patch.object(app_settings, "SETTINGS_FILE", tmp / "settings.json")
no_ssh_thread.start()
no_local_thread.start()
settings_redirect.start()


def make_setup():
    n = next(_counter)
    session_store = SessionStore(path=tmp / f"sessions_{n}.json")
    key_manager = KeyManager(registry_path=tmp / f"keys_{n}.json")
    workspace_store = WorkspaceStore(path=tmp / f"workspaces_{n}.json")
    host_widget = QWidget()
    broadcast = BroadcastManager(lambda: [host_widget])
    cc = ConnectionController(session_store, key_manager, broadcast, parent_widget=host_widget)
    wm = WorkspaceManager(workspace_store, session_store, cc, parent_widget=host_widget)
    return session_store, cc, wm


print("=== 1. Capture : onglet simple + onglet divise ===")
session_store, cc, wm = make_setup()
saved_session = Session(name="prod-web", host="10.0.0.5", username="root")
session_store.add(saved_session)

cc.open_local_terminal()          # onglet 0 : terminal local simple
cc.open_session(saved_session)    # onglet 1 : deviendra un split
cc.split_tab(1, LAYOUT_2V)

workspace = wm.capture(name="Homelab")
print(f"  {len(workspace.tabs)} onglet(s) captures")
assert len(workspace.tabs) == 2
assert workspace.tabs[0].items[0].kind == ITEM_LOCAL_SHELL
assert workspace.tabs[1].layout == LAYOUT_2V
assert len(workspace.tabs[1].items) == 2
assert workspace.tabs[1].items[0].kind == ITEM_SESSION_SSH
assert workspace.tabs[1].items[0].session_id == saved_session.id
assert workspace.tabs[1].items[1].kind == ITEM_LOCAL_SHELL  # panneau de remplissage
print("  OK")

print()
print("=== 2. Sauvegarde persistee (relecture depuis le disque) ===")
saved = wm.save_as_new("Homelab")
reloaded_store = WorkspaceStore(path=wm.store.path)
reloaded = reloaded_store.get(saved.id)
print("  workspace relu:", reloaded.name if reloaded else None)
assert reloaded is not None
assert reloaded.name == "Homelab"
assert len(reloaded.tabs) == 2
assert reloaded.tabs[1].items[0].session_id == saved_session.id
print("  OK")

print()
print("=== 3. Restauration : les onglets sont recrees a l'identique ===")
session_store2, cc2, wm2 = make_setup()
session_store2.add(saved_session)
skipped = wm2.restore(reloaded)
print(f"  onglets ouverts: {cc2.tabs.count()}, elements ignores: {skipped}")
assert cc2.tabs.count() == 2
assert skipped == 0
from app.ui.split_pane import SplitContainer
from app.ui.tabs import SessionTabWidget, LocalTerminalTabWidget
assert isinstance(cc2.tabs.widget(0), LocalTerminalTabWidget)
container = cc2.tabs.widget(1)
assert isinstance(container, SplitContainer)
assert isinstance(container.panes[0].content, SessionTabWidget)
assert container.panes[0].content.session.id == saved_session.id
print("  OK")

print()
print("=== 4. Restauration partielle : session supprimee depuis -> onglet ignore ===")
session_store3, cc3, wm3 = make_setup()
# session_store3 ne contient PAS saved_session : simule une session supprimee
skipped3 = wm3.restore(reloaded)
print(f"  onglets ouverts: {cc3.tabs.count()}, elements ignores: {skipped3}")
assert skipped3 >= 1
assert cc3.tabs.count() == 1  # seul le terminal local (onglet 0) a pu etre restaure
print("  OK")

print()
print("=== 5. Renommer / Supprimer ===")
_, _, wm4 = make_setup()
ws = wm4.save_as_new("temporaire")
wm4.rename(ws.id, "renomme")
assert wm4.store.get(ws.id).name == "renomme"
wm4.delete(ws.id)
assert wm4.store.get(ws.id) is None
print("  OK")

print()
print("=== 6. Enregistrer par-dessus (ecrase le contenu, garde le nom et l'id) ===")
session_store5, cc5, wm5 = make_setup()
cc5.open_local_terminal()
ws5 = wm5.save_as_new("evolutif")
assert len(wm5.store.get(ws5.id).tabs) == 1
cc5.open_local_terminal()
wm5.save_over(ws5.id)
updated = wm5.store.get(ws5.id)
print(f"  onglets apres re-enregistrement: {len(updated.tabs)}")
assert updated.id == ws5.id
assert updated.name == "evolutif"
assert len(updated.tabs) == 2
print("  OK")

print()
print("=== 7. Restauration automatique au demarrage (parametre global) ===")
_, cc6, wm6 = make_setup()
cc6.open_local_terminal()
ws6 = wm6.save_as_new("auto")
assert wm6.try_restore_last_on_startup() is False, "desactive par defaut"
app_settings.set_setting(SETTING_RESTORE_ON_STARTUP, True)
app_settings.set_setting(SETTING_LAST_WORKSPACE_ID, ws6.id)
assert wm6.try_restore_last_on_startup() is True
app_settings.set_setting(SETTING_RESTORE_ON_STARTUP, False)
print("  OK")

no_ssh_thread.stop()
no_local_thread.stop()
settings_redirect.stop()

print()
print("WORKSPACES : TOUS LES TESTS OK")