Add factory to create GUI independent of running it.

Add unittests.
Fix imports to avoid cross contamination between running engines.
Pyright and unittest in Github Actions workflow.

Author: nneskildsf

.github/workflows/build_exe.yml

@@ -19,9 +19,13 @@ jobs:
         with:
           python-version: "3.13"
       - name: Install dependencies
-        run: python -m pip install --upgrade pip pyinstaller
+        run: python -m pip install --upgrade pip pyinstaller pyright
       - name: Install Open Pectus Engine Manager
         run: pip install -e .
+      - name: Type check with pyright
+        run: pyright
+      - name: Test with unittest
+        run: python -m unittest
       - name: Build .exe
         run: pyinstaller pyinstaller.spec
       - name: Zip application

openpectus_engine_manager_gui/__init__.py

@@ -1,15 +1,15 @@
 """Run multiple [Open Pectus](https://github.com/Open-Pectus/Open-Pectus/)
 engines in a convenient user interface."""
+import sys
+INITIAL_MODULES = sys.modules.keys()
 import asyncio
 from collections import defaultdict
 import ctypes
 import json
 import logging
-from logging.handlers import RotatingFileHandler
 import os
 import platform
 import ssl
-import sys
 import threading
 import time
 import tkinter as tk
@@ -24,6 +24,7 @@
 import httpx
 import pystray
 import multiprocess
+import multiprocess.spawn
 
 __version__ = "0.1.0"
 # This application is written for Windows
@@ -119,14 +120,14 @@ class LogRecorder(logging.Handler):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.logs: Dict[str, List[logging.LogRecord]] = defaultdict(list)
-        self.emit_callback: List[Callable] = []
+        self.emit_callbacks: List[Callable] = []
         self.engine_names: List[str] = []
 
     def emit(self, record: logging.LogRecord):
         assert record.threadName is not None
         if record.threadName in self.engine_names:
             self.logs[record.threadName].append(record)
-            for fn in self.emit_callback:
+            for fn in self.emit_callbacks:
                 fn(record, record.threadName)
 
     def clear_log(self, thread_name):
@@ -172,7 +173,7 @@ async def start_engine(loop: asyncio.EventLoop):
             # so don't let threads manipulate it at the same time.
             import_lock.acquire()
             for k in list(sys.modules.keys()):
-                if "openpectus" in k:
+                if k not in INITIAL_MODULES:
                     del sys.modules[k]
             from openpectus.engine.main import create_uod
             from openpectus.engine.engine import Engine
@@ -185,6 +186,9 @@ async def start_engine(loop: asyncio.EventLoop):
             from openpectus.engine.engine_runner import EngineRunner
             from openpectus.protocol.engine_dispatcher import EngineDispatcher
             from openpectus.lang.exec.tags import SystemTagName
+            import logging
+            import os
+            from logging.handlers import RotatingFileHandler
             import_lock.release()
             # Attach log recorder to Open Pectus loggers created on import
             # to catch them and show them in EngineOutput
@@ -297,6 +301,7 @@ async def cancel():
                 cancel(),
                 self.loops[engine_name]
             )
+            self.loops[engine_name].stop()
 
     def validate_engine(self, engine_item: Dict[str, str]):
         engine_name = engine_item["engine_name"]
@@ -306,9 +311,12 @@ def validate():
             # Remove cached modules to avoid cross-contamination
             import_lock.acquire()
             for k in list(sys.modules.keys()).copy():
-                if "openpectus" in k:
+                if k not in INITIAL_MODULES:
                     del sys.modules[k]
             from openpectus.engine.main import validate_and_exit
+            import logging
+            import os
+            from logging.handlers import RotatingFileHandler
             import_lock.release()
             # Attach log recorder to Open Pectus logs to catch them
             # and show them in EngineOutput
@@ -1098,7 +1106,7 @@ def _about(self):
         )
 
 
-def main():
+def assemble_gui() -> OpenPectusEngineManagerGui:
     # Instantiate objects
     persistent_data = PersistentData()
     gui = OpenPectusEngineManagerGui(persistent_data)
@@ -1116,8 +1124,8 @@ def main():
     gui.engine_list.on_validate_callback.append(engine_manager.validate_engine)
     gui.add_engine_callback.append(lambda x: log_recorder.engine_names.append(x))
     gui.remove_engine_callback.append(lambda x: log_recorder.engine_names.remove(x))
-    log_recorder.emit_callback.append(gui.engine_list.set_tag_for_engine_name)
-    log_recorder.emit_callback.append(
+    log_recorder.emit_callbacks.append(gui.engine_list.set_tag_for_engine_name)
+    log_recorder.emit_callbacks.append(
         gui.engine_output.insert_log_record_for_engine
     )
     # Override methods
@@ -1127,10 +1135,15 @@ def main():
     # Populate GUI with persistent data
     for uod_filename in persistent_data["uods"]:
         gui.load_uod_file(uod_filename)
+    return gui
+
+
+def main():
+    gui = assemble_gui()
     # Start Tk event loop
     gui.mainloop()
 
 
 if __name__ == "__main__":
-    multiprocess.freeze_support()
+    multiprocess.spawn.freeze_support()
     main()

openpectus_engine_manager_gui/test.py

@@ -0,0 +1,132 @@
+import unittest
+import os
+import time
+from logging.handlers import BufferingHandler
+from typing import List
+
+import openpectus_engine_manager_gui
+from openpectus.engine.configuration import demo_uod
+
+gui = openpectus_engine_manager_gui.assemble_gui()
+gui.icon.stop()
+
+
+class TestPersistentData(unittest.TestCase):
+    def test_persistent_data_exists(self):
+        self.assertTrue(os.path.isfile(gui.persistent_data.filename))
+
+    def test_read_write_persistent_data(self):
+        data = gui.persistent_data
+        keys = [
+            "aggregator_hostname",
+            "aggregator_port",
+            "aggregator_secure",
+            "uods",
+        ]
+        for key in keys:
+            data[key] = data[key]
+
+
+def engine_manager_factory(uods: List[str]) -> openpectus_engine_manager_gui.EngineManager:
+    # Set up Engine Manager object with Null logging
+    # handler and dict in memory instead of persistent
+    # data. Override set_status_for_item with no-op.
+    em = openpectus_engine_manager_gui.EngineManager(
+        BufferingHandler(1000),  # Capacity of 1000 records
+        dict(
+            aggregator_hostname="github.openpectus.org",
+            aggregator_port=443,
+            aggregator_secure=True,
+            uods=[demo_uod.__file__],
+        ),
+    )
+    return em
+
+
+class TestEngineManager(unittest.TestCase):
+    def test_start_stop_engine(self):
+        # Test using demo UOD shipped with Open Pectus
+        uods = [demo_uod.__file__]
+        engine_item = dict(
+                engine_name="Unittest",
+                filename=demo_uod.__file__,
+        )
+        # Create list to hold engine status messages
+        status_list = list()
+        # Create Engine Manager
+        em = engine_manager_factory(uods)
+        em.set_status_for_item = lambda status, item: status_list.append(status)
+        # Start engine and wait until fully started
+        em.start_engine(engine_item)
+        t0 = time.time()
+        assert isinstance(em.log_handler, BufferingHandler)
+        while True:
+            buffer = em.log_handler.buffer
+            if len(buffer) and buffer[-1].msg == "Started steady-state sending loop":
+                break
+            if time.time() - t0 >= 10:
+                raise Exception("Engine manager was unable to start engine.")
+            time.sleep(1)
+        # Check engine is running properly
+        self.assertIn(engine_item["engine_name"], em.loops)
+        self.assertIn(engine_item["engine_name"], em.threads)
+        loop = em.loops[engine_item["engine_name"]]
+        thread = em.threads[engine_item["engine_name"]]
+        self.assertTrue(loop.is_running())
+        self.assertTrue(thread.is_alive())
+        # Stop engine
+        em.stop_engine(engine_item)
+        t0 = time.time()
+        while loop.is_running() or thread.is_alive():
+            if time.time() - t0 >= 10:
+                raise Exception("Engine manager was unable to stop engine.")
+            time.sleep(1)
+
+    def test_validate_engine(self):
+        # Test using demo UOD shipped with Open Pectus
+        uods = [demo_uod.__file__]
+        engine_item = dict(
+                engine_name="Unittest",
+                filename=demo_uod.__file__,
+        )
+        # Create list to hold engine status messages
+        status_list = list()
+        # Create Engine Manager
+        em = engine_manager_factory(uods)
+        em.set_status_for_item = lambda status, item: status_list.append(status)
+        # Validate engine and wait until complete
+        em.validate_engine(engine_item)
+        self.assertIn(engine_item["engine_name"], em.threads)
+        thread = em.threads[engine_item["engine_name"]]
+        t0 = time.time()
+        while thread.is_alive():
+            if time.time() - t0 >= 30:
+                raise Exception("Engine manager was unable to validate engine.")
+            time.sleep(1)
+        self.assertTrue(len(status_list))
+        self.assertEqual(status_list[0], "Not running")
+
+    def test_validate_multiple_engines_simultaneously(self):
+        # Test using demo UOD shipped with Open Pectus
+        uods = [demo_uod.__file__]
+        engine_item = dict(
+                engine_name="Unittest",
+                filename=demo_uod.__file__,
+        )
+        threads = []
+        for i in range(5):
+            # Create Engine Manager
+            em = engine_manager_factory(uods)
+            em.set_status_for_item = lambda status, item: None
+            # Validate engine and wait until complete
+            em.validate_engine(engine_item)
+            threads.append(em.threads[engine_item["engine_name"]])
+        t0 = time.time()
+        while any([thread.is_alive() for thread in threads]):
+            if time.time() - t0 >= 60:
+                raise Exception("Engine manager was unable to validate engine.")
+            time.sleep(1)
+
+
+if __name__ == "__main__":
+    unittest.main()