tests(P0): couvrir le flux d'installation engines et l'analyseur deps

- Ajoute des tests de non-regression pour garantir l'ordre systeme puis Python dans EngineLoader/base.py, y compris le cas d'echec systeme.

- Ajoute des tests heuristiques pour l'analyseur de dependances (racines internes via __init__, metadata projet, classification internal/third_party).

- Met a jour TODO.md pour marquer les taches P0 de tests comme realisees.

Author: raidos23

TODO.md

@@ -8,8 +8,8 @@
 ### Phase 2 - Securiser les flux critiques (P0)
 - [x] Orchestrer les installs outils en sequence stricte: systeme puis Python.
 - [x] En cas d'echec systeme, journaliser proprement puis continuer la phase Python.
-- [ ] Ajouter des tests unitaires sur `EngineLoader/base.py` (ordre d'execution et cas d'echec).
-- [ ] Ajouter des tests de non-regression sur `Core/deps_analyser/analyser.py`.
+- [x] Ajouter des tests unitaires sur `EngineLoader/base.py` (ordre d'execution et cas d'echec).
+- [x] Ajouter des tests de non-regression sur `Core/deps_analyser/analyser.py`.
 
 ### Phase 3 - Fiabiliser l'analyseur de dependances (P0)
 - [x] Renforcer la classification `stdlib/internal/third_party/unknown`.

tests/test_deps_analyser_heuristics.py

@@ -0,0 +1,141 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2026 Ague Samuel Amen
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from types import SimpleNamespace
+import types
+import importlib.util
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[1]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+qtcore = types.ModuleType("PySide6.QtCore")
+qtwidgets = types.ModuleType("PySide6.QtWidgets")
+pyside6 = types.ModuleType("PySide6")
+core_pkg = types.ModuleType("Core")
+widgets_creator = types.ModuleType("Core.WidgetsCreator")
+i18n = types.ModuleType("Core.i18n")
+
+
+class _DummyQProcess:
+    pass
+
+
+class _DummyApp:
+    @staticmethod
+    def processEvents():
+        return None
+
+
+class _DummyMessageBox:
+    Yes = 1
+    No = 0
+    ActionRole = 0
+    AcceptRole = 1
+    RejectRole = 2
+
+
+class _DummyProgressDialog:
+    def __init__(self, *_args, **_kwargs):
+        pass
+
+
+def _dummy_log(*_args, **_kwargs):
+    return None
+
+
+qtcore.QProcess = _DummyQProcess
+qtwidgets.QApplication = _DummyApp
+qtwidgets.QMessageBox = _DummyMessageBox
+widgets_creator.ProgressDialog = _DummyProgressDialog
+i18n.log_with_level = _dummy_log
+pyside6.QtCore = qtcore
+pyside6.QtWidgets = qtwidgets
+core_pkg.WidgetsCreator = widgets_creator
+core_pkg.i18n = i18n
+
+sys.modules.setdefault("PySide6", pyside6)
+sys.modules.setdefault("PySide6.QtCore", qtcore)
+sys.modules.setdefault("PySide6.QtWidgets", qtwidgets)
+sys.modules.setdefault("Core", core_pkg)
+sys.modules.setdefault("Core.WidgetsCreator", widgets_creator)
+sys.modules.setdefault("Core.i18n", i18n)
+
+_ANALYSER_PATH = ROOT / "Core" / "deps_analyser" / "analyser.py"
+_SPEC = importlib.util.spec_from_file_location("ark_test_analyser", _ANALYSER_PATH)
+assert _SPEC and _SPEC.loader
+da = importlib.util.module_from_spec(_SPEC)
+_SPEC.loader.exec_module(da)
+
+
+@pytest.fixture(autouse=True)
+def _clear_caches() -> None:
+    da._is_stdlib_module.cache_clear()
+    da._classify_module_origin.cache_clear()
+
+
+def test_collect_workspace_module_roots_supports_init_chain_and_metadata(
+    tmp_path: Path,
+) -> None:
+    ws = tmp_path / "workspace"
+    (ws / "src" / "acme_pkg").mkdir(parents=True)
+    (ws / "src" / "acme_pkg" / "__init__.py").write_text("", encoding="utf-8")
+    (ws / "src" / "acme_pkg" / "main.py").write_text("import os\n", encoding="utf-8")
+
+    (ws / "app" / "core").mkdir(parents=True)
+    (ws / "app" / "core" / "__init__.py").write_text("", encoding="utf-8")
+
+    (ws / "pyproject.toml").write_text(
+        "[project]\nname = 'ark-project'\n", encoding="utf-8"
+    )
+    (ws / "setup.cfg").write_text(
+        "[metadata]\nname = awesome-lib\n", encoding="utf-8"
+    )
+
+    filtered = [
+        str(ws / "src" / "acme_pkg" / "__init__.py"),
+        str(ws / "src" / "acme_pkg" / "main.py"),
+        str(ws / "app" / "core" / "__init__.py"),
+    ]
+    roots = da._collect_workspace_module_roots(filtered, str(ws))
+
+    assert "acme_pkg" in roots
+    assert "app" in roots
+    assert "ark_project" in roots
+    assert "awesome_lib" in roots
+
+
+def test_classify_module_origin_internal_from_workspace_spec(
+    tmp_path: Path, monkeypatch
+) -> None:
+    ws = tmp_path / "workspace"
+    (ws / "pkg").mkdir(parents=True)
+    origin = str(ws / "pkg" / "__init__.py")
+    (ws / "pkg" / "__init__.py").write_text("", encoding="utf-8")
+
+    monkeypatch.setattr(da, "_is_stdlib_module", lambda _name: False)
+    monkeypatch.setattr(
+        "importlib.util.find_spec",
+        lambda _name: SimpleNamespace(origin=origin, submodule_search_locations=[]),
+    )
+
+    assert da._classify_module_origin("pkg", str(ws)) == "internal"
+
+
+def test_classify_module_origin_third_party_from_site_packages(monkeypatch) -> None:
+    monkeypatch.setattr(da, "_is_stdlib_module", lambda _name: False)
+    monkeypatch.setattr(
+        "importlib.util.find_spec",
+        lambda _name: SimpleNamespace(
+            origin="/tmp/venv/lib/python3.13/site-packages/requests/__init__.py",
+            submodule_search_locations=[],
+        ),
+    )
+
+    assert da._classify_module_origin("requests", "/tmp/workspace") == "third_party"

tests/test_engine_install_flow.py

@@ -0,0 +1,121 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2026 Ague Samuel Amen
+
+from __future__ import annotations
+
+import sys
+import types
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from EngineLoader.base import CompilerEngine
+
+
+class _LogCapture:
+    def __init__(self) -> None:
+        self.lines: list[str] = []
+
+    def append(self, text: str) -> None:
+        self.lines.append(text)
+
+    def __bool__(self) -> bool:
+        return True
+
+
+class _FakeProc:
+    def __init__(self, wait_ok: bool = True, exit_code: int = 0) -> None:
+        self._wait_ok = wait_ok
+        self._exit_code = exit_code
+
+    def waitForFinished(self, _timeout_ms: int) -> bool:
+        return self._wait_ok
+
+    def exitCode(self) -> int:
+        return self._exit_code
+
+
+class _FakeVenvManager:
+    def __init__(self, events: list[str], missing_python: set[str]) -> None:
+        self._events = events
+        self._missing_python = missing_python
+
+    def is_tool_installed_system(self, tool: str) -> bool:
+        return tool not in self._missing_python
+
+    def ensure_tools_installed_system(self, tools: list[str]) -> None:
+        self._events.append(f"python_install:{','.join(tools)}")
+
+    def resolve_project_venv(self) -> str | None:
+        return "/tmp/fake-venv"
+
+    def is_tool_installed(self, _venv: str, tool: str) -> bool:
+        return tool not in self._missing_python
+
+    def ensure_tools_installed(self, _venv: str, tools: list[str]) -> None:
+        self._events.append(f"python_install:{','.join(tools)}")
+
+
+class _FakeGui:
+    def __init__(self, events: list[str], missing_python: set[str]) -> None:
+        self.log = _LogCapture()
+        self.venv_manager = _FakeVenvManager(events, missing_python)
+        self.use_system_python = True
+        self.sys_deps_manager = None
+
+    def tr(self, fr: str, en: str) -> str:
+        return en
+
+
+class _TestEngine(CompilerEngine):
+    @property
+    def required_tools(self) -> dict[str, list[str]]:
+        return {"python": ["pyinstaller"], "system": ["gcc"]}
+
+
+def _install_fake_sysdeps(
+    monkeypatch, events: list[str], *, wait_ok: bool = True, exit_code: int = 0
+) -> None:
+    fake_mod = types.ModuleType("Core.sys_deps")
+
+    def check_system_packages(_tools: list[str]) -> bool:
+        return False
+
+    class SysDependencyManager:
+        def __init__(self, _gui) -> None:
+            pass
+
+        def install_packages_linux(self, tools: list[str]):
+            events.append(f"system_install:{','.join(tools)}")
+            return _FakeProc(wait_ok=wait_ok, exit_code=exit_code)
+
+    fake_mod.check_system_packages = check_system_packages
+    fake_mod.SysDependencyManager = SysDependencyManager
+    monkeypatch.setitem(sys.modules, "Core.sys_deps", fake_mod)
+    monkeypatch.setattr("platform.system", lambda: "Linux")
+
+
+def test_install_order_runs_system_before_python(monkeypatch) -> None:
+    events: list[str] = []
+    _install_fake_sysdeps(monkeypatch, events, wait_ok=True, exit_code=0)
+    gui = _FakeGui(events, missing_python={"pyinstaller"})
+    engine = _TestEngine()
+
+    ok = engine.ensure_tools_installed(gui)
+
+    assert ok is True
+    assert events == ["system_install:gcc", "python_install:pyinstaller"]
+
+
+def test_python_install_still_runs_when_system_install_fails(monkeypatch) -> None:
+    events: list[str] = []
+    _install_fake_sysdeps(monkeypatch, events, wait_ok=True, exit_code=1)
+    gui = _FakeGui(events, missing_python={"pyinstaller"})
+    engine = _TestEngine()
+
+    ok = engine.ensure_tools_installed(gui)
+
+    assert ok is True
+    assert events == ["system_install:gcc", "python_install:pyinstaller"]