refactor: add nil-checks for scheduler (testcase adaption)

src/aura_engine/events.py

@@ -218,7 +218,8 @@ class EngineEventDispatcher:
             self.logger.debug("on_play(..)")
             # Assign timestamp indicating start play time. Use the actual playtime when possible.
             entry.entry_start_actual = datetime.datetime.now()
-            self.scheduler.on_play(entry)
+            if self.scheduler is not None:
+                self.scheduler.on_play(entry)
             self.call_event("on_play", entry)
 
         thread = Thread(target=func, args=(self, entry))

src/aura_engine/plugins/clock.py

@@ -106,11 +106,14 @@ class ClockInfoHandler:
             entry (PlaylistEntry):
 
         """
-        active_playlist_type, active_playlist = self.engine.scheduler.get_active_playlist()
-        active_type_id = active_playlist_type.get("id")
-        active_timeslot = self.engine.scheduler.timetable.get_current_timeslot()
-        upcoming_timeslots = self.engine.scheduler.timetable.get_next_timeslots()
-        self.post_clock_info(active_type_id, active_playlist, active_timeslot, upcoming_timeslots)
+        if self.engine.scheduler is not None:
+            active_playlist_type, active_playlist = self.engine.scheduler.get_active_playlist()
+            active_type_id = active_playlist_type.get("id")
+            active_timeslot = self.engine.scheduler.timetable.get_current_timeslot()
+            upcoming_timeslots = self.engine.scheduler.timetable.get_next_timeslots()
+            self.post_clock_info(
+                active_type_id, active_playlist, active_timeslot, upcoming_timeslots
+            )
 
     def post_clock_info(self, active_type, active_playlist, active_timeslot, upcoming_timeslots):
         """

src/aura_engine/scheduling/scheduler.py

@@ -574,4 +574,5 @@ class PlayCommand(EngineExecutor):
                 time.sleep(2)
 
         self.engine.player.play(entries[0], Player.TransitionType.FADE)
-        self.logger.info(self.engine.scheduler.timetable_renderer.get_ascii_timeslots())
+        if self.engine.scheduler is not None:
+            self.logger.info(self.engine.scheduler.timetable_renderer.get_ascii_timeslots())

tests/test_engine_scheduler.py

@@ -24,6 +24,7 @@ from time import sleep
 from flask import Flask
 from flask_sqlalchemy import SQLAlchemy
 
+from aura_engine.base.logger import AuraLogger
 from aura_engine.base.utils import SimpleUtil as SU
 from aura_engine.core.channels import ChannelName
 from aura_engine.core.client import CoreClient, PlayoutClient
@@ -71,7 +72,7 @@ from aura_engine.events import EngineEventDispatcher
 
 class CoreClientMock(CoreClient):
     """
-    Client managing communication with Engine Core (Liquidsoap).
+    Suppress unwanted behavior by subclassing and overriding.
     """
 
     instance = None
@@ -99,15 +100,11 @@ class CoreClientMock(CoreClient):
 
     @synchronized
     def connect(self):
-        """
-        Open connection.
-        """
+        pass
 
     @synchronized
     def disconnect(self):
-        """
-        Close connection.
-        """
+        pass
 
     @synchronized
     def exec(self, namespace: str, action: str, args: str = "") -> str:
@@ -127,31 +124,22 @@ class CoreClientMock(CoreClient):
 
 class PlayoutClientMock(CoreClientMock):
     """
-    Client managing communication with Engine Core (Liquidsoap).
+    Mock PlayoutClient by subclssing and skipping unwanted.
     """
 
-    mixer = None
+    mixer: Mixer = None
 
     def __init__(self, event_dispatcher: EngineEventDispatcher):
-        """
-        Initialize the client.
-        """
         super().__init__(event_dispatcher)
         self.mixer = Mixer("mixer", self)
 
     @staticmethod
     def get_instance(event_dispatcher: EngineEventDispatcher) -> CoreClientMock:
-        """
-        Get an instance of the client singleton.
-        """
         if not PlayoutClientMock.instance:
             PlayoutClientMock.instance = PlayoutClientMock(event_dispatcher)
         return PlayoutClientMock.instance
 
     def get_mixer(self):
-        """
-        Get the mixer instance.
-        """
         return self.mixer
 
 
@@ -160,23 +148,25 @@ class TestPlayCommand(unittest.TestCase):
     Testing the PlayCommand.
     """
 
+    engine: Engine = None
+
     def setUp(self):
+        config = AuraConfig.instance.config
+        AuraLogger(config)
+        self.logger = logging.getLogger("engine-tests")
+
         app = Flask(__name__)
         app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite://"
-        app.config["BABEL_DEFAULT_LOCALE"] = "de"
-        app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
         DB.set_flask_db(SQLAlchemy(app))
         AuraDatabaseModel.recreate_db()
 
-        self.engine = Engine()
-        self.dispatcher = EngineEventDispatcher(engine=self.engine)
-        self.playout = PlayoutClientMock(event_dispatcher=self.dispatcher)
-        self.player = Player(playout=self.playout, event_dispatcher=self.dispatcher)
-        self.engine.player = self.player
-
-        # scheduler = AuraScheduler(self.engine)
-        # self.engine.scheduler = scheduler
-        # self.engine.start()
+        engine = Engine()
+        dispatcher = EngineEventDispatcher(engine=engine)
+        playout = PlayoutClientMock(event_dispatcher=dispatcher)
+        engine.player = Player(playout=playout, event_dispatcher=dispatcher)
+        # engine.scheduler = AuraScheduler(engine)
+        # engine.start()
+        self.engine = engine
 
     def test_play(self):
         print(self._testMethodName)
@@ -203,7 +193,7 @@ class TestPlayCommand(unittest.TestCase):
         command.do_preload(entries)
         command.do_play(entries)
 
-        assert entries[-1].status == Player.EntryPlayState.READY
+        self.assertEqual(entries[-1].status, Player.EntryPlayState.READY)
 
 
 if __name__ == "__main__":