test update

tests/test_notificationsmanager_logging.py

@@ -0,0 +1,78 @@
+"""Notification logging must avoid stack inspection without changing delivery."""
+import logging
+from pathlib import Path
+import sys
+from types import SimpleNamespace
+import unittest
+from unittest.mock import Mock, call, patch
+
+sys.path[:0] = [str(Path(__file__).resolve().parents[1] / 'apps'),
+                str(Path(__file__).resolve().parents[1] / 'apps/ad_toolbox')]
+from appdaemon.adapi import ADAPI
+from notificationsmanager import NotificationsManager, Notification, SmartCondition
+
+
+class NotificationLoggingTests(unittest.TestCase):
+    def setUp(self):
+        self.api = ADAPI.__new__(ADAPI)
+        self.api.AD = SimpleNamespace(config=SimpleNamespace(ascii_encode=False))
+        self.api.logger = Mock()
+        self.sinks = {'main_log': Mock(), 'error_log': Mock()}
+        self.api.get_user_log = Mock(side_effect=self.sinks.__getitem__)
+        self.app = NotificationsManager.__new__(NotificationsManager)
+        self.app.get_ad_api = Mock(return_value=self.api)
+        self.app.args = {}
+        self.app.call_service = Mock()
+        self.app.run_in = Mock()
+        self.app.stop_app = Mock()
+        self.app._config_model = SimpleNamespace(name='notifications_manager')
+        self.app.initialize()
+        self.config = {
+            'message': {'title': 'Alarme', 'content': 'Activée', 'timeout': 10,
+                        'data': {'tag': 'alarm'}},
+            'recipients': {'phones': {'services': ['notify/one', 'notify/two']}}
+        }
+        self.notification = Notification(self.app, {'message': {}, 'recipients': {}}, 'alarm')
+        self.notification.config = self.config
+
+    def test_send_and_clear_keep_delivery_without_inspecting_stack(self):
+        with patch('appdaemon.adapi.inspect.stack', side_effect=AssertionError('stack inspection')):
+            self.notification.send_notification('phones')
+            self.notification.clear_notification('phones', 'alarm')
+        self.app.call_service.assert_has_calls([
+            call('notify/one', title='Alarme', message='Activée', data={'tag': 'alarm'}),
+            call('notify/two', title='Alarme', message='Activée', data={'tag': 'alarm'}),
+            call('notify/one', message='clear_notification', data={'tag': 'alarm'}),
+            call('notify/two', message='clear_notification', data={'tag': 'alarm'}),
+        ])
+        self.app.run_in.assert_called_once_with(self.notification.on_timeout_expired, 10,
+                                                tag='alarm', recipient='phones')
+        self.assertEqual(self.api.logger.log.call_count, 4)
+        self.api.get_user_log.assert_not_called()
+
+    def test_errors_use_app_logger_and_error_log_and_stop(self):
+        with patch('appdaemon.adapi.inspect.stack', side_effect=AssertionError('stack inspection')):
+            self.app.log_error('Échec', stop_app=True)
+        for sink in (self.api.logger, self.sinks['error_log']):
+            self.assertEqual(sink.log.call_args.args, (logging.ERROR, 'Échec'))
+        self.sinks['main_log'].log.assert_not_called()
+        self.app.stop_app.assert_called_once_with('notifications_manager')
+
+    def test_smartcondition_fallback_uses_initialized_interface(self):
+        self.config['recipients']['phones']['conditions'] = True
+        self.app.args = {'notifications': {'alarm': self.config}}
+        real_class = SmartCondition.Evaluator
+        def factory(api, *args, **kwargs):
+            condition = real_class.__new__(real_class)
+            condition._Evaluator__logger_interface = None
+            condition._Evaluator__appdaemon_api = api
+            condition._Evaluator__log_info('Condition évaluée')
+            return condition
+        with patch('appdaemon.adapi.inspect.stack', side_effect=AssertionError('stack inspection')):
+            with patch.object(SmartCondition, 'Evaluator', side_effect=factory):
+                self.app.initialize()
+        self.assertEqual(self.api.logger.log.call_args.args, (logging.INFO, 'Condition évaluée'))
+
+
+if __name__ == '__main__':
+    unittest.main()