Merge branch 'init-event-discard'

Author: jsl12

tests/conf/apps/event_test_app.py

@@ -17,6 +17,7 @@ class TestEventCallback(ADAPI):
         listen_kwargs: The keyword arguments to pass to the listen_event method
         fire_kwargs: The keyword arguments to pass to the fire_event method
     """
+
     def initialize(self):
         self.execute_event = asyncio.Event()
         self.listen_event(self.event_callback, self.event, **self.listen_kwargs)

tests/conf/apps/scheduler_test_app.py

@@ -5,15 +5,18 @@
 
 class SchedulerTestAppMode(str, Enum):
     """Enum for different modes of the SchedulerTestApp."""
+
     RUN_EVERY = "run_every"
 
 
 class SchedulerTestApp(ADAPI):
     def initialize(self):
-        self.set_log_level('DEBUG')
+        self.set_log_level("DEBUG")
         self.log("SchedulerTestApp initialized")
         self.set_namespace("test")
+        self.run_in(self.setup_callback, delay=self.register_delay)
 
+    def setup_callback(self, **kwargs) -> None:
         self.log(f"Running in {self.mode} mode")
         match self.mode:
             case SchedulerTestAppMode.RUN_EVERY:
@@ -26,30 +29,41 @@ def initialize(self):
     def mode(self) -> SchedulerTestAppMode:
         return SchedulerTestAppMode(self.args.get("mode", SchedulerTestAppMode.RUN_EVERY))
 
+    @property
+    def register_delay(self) -> float:
+        return self.args.get("register_delay", 0.5)
+
     def run_every_callback(self, **kwargs) -> None:
         """Callback function for run_every."""
         self.log(f"Run every callback executed with kwargs: {kwargs}")
 
 
-
 class TestSchedulerRunIn(ADAPI):
     """A test app to verify run_in functionality."""
 
     def initialize(self):
+        self.set_log_level("DEBUG")
         self.set_namespace("test")
-
-        assert "delay" in self.args, "Delay argument is required"
-        delay = self.args["delay"]
-        self.logger.info(f"Running with a delay of {delay} seconds")
-
-        self.run_in(self.run_in_callback, delay=delay, test_id=self.test_id)
+        self.run_in(self.setup_callback, delay=self.register_delay)
         self.logger.info(f"{self.__class__.__name__} initialized")
 
     @property
     def test_id(self) -> str:
         """Unique identifier for the test run."""
         return self.args.get("test_id", "default_test_id")
 
+    @property
+    def register_delay(self) -> float:
+        return self.args.get("register_delay", 0.5)
+
+    def setup_callback(self, **kwargs) -> None:
+        assert "delay" in self.args, "Delay argument is required"
+        delay = self.args["delay"]
+        self.logger.info(f"Running with a delay of {delay} seconds")
+
+        self.run_in(self.run_in_callback, delay=delay, test_id=self.test_id)
+        # self.log(json.dumps(self.get_scheduler_entries(), default=str, indent=2))
+
     def run_in_callback(self, **kwargs) -> None:
         """Callback function for run_in."""
         self.logger.info("Run in callback executed with kwargs: %s", kwargs)

tests/conf/apps/state_test_app.py

@@ -20,7 +20,6 @@ def _generate_next_value_(name, start, count, last_values):
     NEW_ATTRIBUTE_FILTER_NEGATIVE = auto()
 
 
-
 TEST_ENTITY = "test.some_entity"
 
 
@@ -55,7 +54,7 @@ def state_callback(self, entity: str, attribute: str, old: Any, new: Any, **kwar
         assert isinstance(entity, str), "Entity should be a string"
         assert isinstance(attribute, str), "Attribute should be a string"
 
-        self.log(f' {entity}.{attribute} '.center(40, '-'))
+        self.log(f" {entity}.{attribute} ".center(40, "-"))
         self.log(f"{entity}.{attribute} changed from {old} to {new} with kwargs: {kwargs}")
 
         new_state = self.get_state(entity, attribute="all")

tests/conftest.py

@@ -141,14 +141,14 @@ def logging_obj() -> Logging:
 
 AsyncTempTest = Callable[..., AbstractAsyncContextManager[tuple[AppDaemon, pytest.LogCaptureFixture]]]
 
+
 @pytest_asyncio.fixture(scope="function")
 async def run_app_for_time(ad: AppDaemon, caplog: pytest.LogCaptureFixture) -> AsyncTempTest:
     @asynccontextmanager
     async def _run(app_name: str, run_time: float | None = None, **kwargs):
         with caplog.at_level(logging.DEBUG, logger=f"AppDaemon.{app_name}"):
             async with ad.app_management.app_run_context(app_name, **kwargs):
                 logger.info(f"===== Running app {app_name} for {format_timedelta(run_time)}")
-                logger.info(f"Temporarily adding args to app: {kwargs}")
                 if run_time is not None:
                     await asyncio.sleep(run_time)
                 logger.info("=== Done, yielding caplog for inspection")

tests/functional/test_event.py

@@ -9,10 +9,12 @@
 
 logger = logging.getLogger("AppDaemon._test")
 
+
 @pytest.mark.ci
 @pytest.mark.functional
 class TestEventCallback:
     """Class to group the various tests for event callbacks."""
+
     app_name: str = "test_event_app"
 
     @pytest.mark.asyncio(loop_scope="session")

tests/functional/test_run_every.py

@@ -25,17 +25,19 @@ async def test_run_every(
     run_app_for_time: AsyncTempTest,
     interval: str | int | float | timedelta,
     start: str,
-    n: int = 5,
+    n: int = 2,
 ) -> None:
     interval = parse_timedelta(interval)
     run_time = (interval * n) + timedelta(seconds=0.01)
+    register_delay = 0.1
+    run_time += timedelta(seconds=register_delay)  # Accounts for the delay in registering the callback
     if (parts := re.split(r"\s+[\+]\s+", start)) and len(parts) == 2:
         _, offset = parts
         run_time += parse_timedelta(offset)
 
     app_name = "scheduler_test_app"
     test_id = str(uuid.uuid4())
-    app_args = dict(start=start, interval=interval, msg=test_id)
+    app_args = dict(start=start, interval=interval, msg=test_id, register_delay=register_delay)
     async with run_app_for_time(app_name, run_time=run_time.total_seconds(), **app_args) as (ad, caplog):
         check_interval_partial = partial(check_interval, caplog, f"kwargs: {{'msg': '{test_id}',")
 

tests/functional/test_run_in.py

@@ -14,12 +14,15 @@
 async def test_run_in_delay(run_app_for_time, delay):
     run_time = parse_timedelta(delay).total_seconds()
     run_time += ERROR_MARGIN * 10
+    register_delay = 0.1
+    run_time += register_delay
     test_id = str(uuid.uuid4())  # Generate a unique test ID for each run
-    async with run_app_for_time("test_run_in", run_time=run_time, delay=delay, test_id=test_id) as (ad, caplog):
+    kwargs = dict(delay=delay, test_id=test_id, register_delay=register_delay)
+    async with run_app_for_time("test_run_in", run_time=run_time, **kwargs) as (ad, caplog):
         assert "TestSchedulerRunIn initialized" in caplog.text
         for record in caplog.records:
             match record:
-                case logging.LogRecord(msg="TestSchedulerRunIn initialized", created=created_ts):
+                case logging.LogRecord(msg=msg, created=created_ts) if msg.startswith("Registering run_in"):
                     # Nothing really needs to happen here. The created_ts variable is set if the record is matched.
                     # It's already been asserted that this text is somewhere in the caplog text, so this is guaranteed to
                     # match one of the records.
@@ -37,3 +40,4 @@ async def test_run_in_delay(run_app_for_time, delay):
         else:
             # If it reaches here, no matching record was found
             assert False, "Run in callback was not executed"
+            assert False, "Run in callback was not executed"

tests/functional/test_state.py

@@ -11,15 +11,14 @@
 logger = logging.getLogger("AppDaemon._test")
 
 
-
 @pytest.mark.ci
 @pytest.mark.functional
 class TestStateCallback:
     """Class to group the various tests for state callbacks."""
+
     app_name: str = "state_test_app"
     timeout: int | float = 0.6
 
-
     async def _run_callback_test(self, run_app_for_time: AsyncTempTest, app_args: dict, sign: bool) -> None:
         """Helper method to run callback tests with common logic.
 
@@ -33,15 +32,15 @@ async def _run_callback_test(self, run_app_for_time: AsyncTempTest, app_args: di
                     wait_coro = asyncio.wait_for(app_obj.execute_event.wait(), timeout=self.timeout)
                     if sign:
                         await wait_coro
-                        logger.debug('Callback execute event was set')
+                        logger.debug("Callback execute event was set")
                     else:
                         # We expect the timeout because the new state filter doesn't match
                         with pytest.raises(asyncio.TimeoutError):
                             await wait_coro
-                        logger.debug('Callback execute event was not set')
+                        logger.debug("Callback execute event was not set")
                 case _:
                     raise ValueError("App object not found in app management")
-        logger.debug(f'Test completed in {perf_counter() - start:.3f} seconds')
+        logger.debug(f"Test completed in {perf_counter() - start:.3f} seconds")
 
     @pytest.mark.parametrize("sign", [True, False])
     @pytest.mark.asyncio(loop_scope="session")
@@ -105,20 +104,19 @@ async def test_old_state_callback(self, run_app_for_time: AsyncTempTest, sign: b
         async with run_app_for_time(self.app_name, **app_args) as (ad, caplog):
             match ad.app_management.objects.get(self.app_name):
                 case ManagedObject(object=app_obj):
-                    app_obj.run_in(app_obj.test_change_state, delay=app_obj.delay*2, state="abc")
-                    wait_coro = asyncio.wait_for(app_obj.execute_event.wait(), timeout=self.timeout*2)
+                    app_obj.run_in(app_obj.test_change_state, delay=app_obj.delay * 2, state="abc")
+                    wait_coro = asyncio.wait_for(app_obj.execute_event.wait(), timeout=self.timeout * 2)
                     if sign:
                         await wait_coro
-                        logger.debug('Callback execute event was set')
+                        logger.debug("Callback execute event was set")
                     else:
                         # We expect the timeout because the new state filter doesn't match
                         with pytest.raises(asyncio.TimeoutError):
                             await wait_coro
-                        logger.debug('Callback execute event was not set')
+                        logger.debug("Callback execute event was not set")
                 case _:
                     raise ValueError("App object not found in app management")
 
-
     @pytest.mark.parametrize("sign", [True, False])
     @pytest.mark.asyncio(loop_scope="session")
     async def test_attribute_callback(self, run_app_for_time: AsyncTempTest, sign: bool) -> None:
@@ -144,8 +142,5 @@ async def test_attribute_callback(self, run_app_for_time: AsyncTempTest, sign: b
         """
         new_state = str(uuid.uuid4())
         listen_state = new_state if sign else str(uuid.uuid4())
-        app_args = {
-            "listen_kwargs": {"attribute": "test_attr", "new": listen_state},
-            "state_kwargs": {"state": "changed", "test_attr": new_state}
-        }
+        app_args = {"listen_kwargs": {"attribute": "test_attr", "new": listen_state}, "state_kwargs": {"state": "changed", "test_attr": new_state}}
         await self._run_callback_test(run_app_for_time, app_args, sign)

tests/functional/utils.py

@@ -10,7 +10,6 @@
 AsyncTempTest = Callable[..., AbstractAsyncContextManager[tuple[AppDaemon, pytest.LogCaptureFixture]]]
 
 
-
 def check_interval(
     caplog: pytest.LogCaptureFixture,
     search_str: str,
@@ -20,4 +19,4 @@ def check_interval(
 ) -> None:
     logs = list(filter_caplog(caplog, search_str))
     assert_timedelta(logs, interval, buffer)
-    assert len(logs) == n, f"Expected {n} log entries with '{search_str}', found {len(logs)}"
+    assert len(logs) >= n, f"Expected {n} log entries with '{search_str}', found {len(logs)}"

tests/unit/datetime/test_now_is_between.py

@@ -10,6 +10,7 @@
     pytest.mark.unit,
 ]
 
+
 def test_between_overnight(location: Location, early_now: datetime, default_now: datetime, late_now: datetime) -> None:
     sun_check = partial(utils.now_is_between, start_time="sunset", end_time="sunrise", location=location)
     assert sun_check(now=early_now), "The early time is not between sunset and sunrise, but should be"