PyEmailerAJM 1.9.2__tar.gz → 1.9.3__tar.gz

{pyemailerajm-1.9.2 → pyemailerajm-1.9.3}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: PyEmailerAJM
-Version: 1.9.2
+Version: 1.9.3
 Summary: Allows for automating sending Email with the Outlook Desktop client. Future releases will add more client support
 Home-page: https://github.com/amcsparron2793-Water/PyEmailer
-Download-URL: https://github.com/amcsparron2793-Water/PyEmailer/archive/refs/tags/1.9.2.tar.gz
+Download-URL: https://github.com/amcsparron2793-Water/PyEmailer/archive/refs/tags/1.9.3.tar.gz
 Author: Amcsparron
 Author-email: amcsparron@albanyny.gov
 License: MIT License

pyemailerajm-1.9.3/PyEmailerAJM/_version.py

@@ -0,0 +1 @@
+__version__ = '1.9.3'

{pyemailerajm-1.9.2 → pyemailerajm-1.9.3}/PyEmailerAJM/backend/logger.py

@@ -1,7 +1,8 @@
 from logging import Filter, DEBUG, ERROR, Handler, FileHandler, StreamHandler, Logger, WARNING
 from typing import Union
 
-from EasyLoggerAJM import EasyLogger, OutlookEmailHandler, StreamHandlerIgnoreExecInfo
+from EasyLoggerAJM import EasyLogger
+from EasyLoggerAJM.logger_parts import OutlookEmailHandler, StreamHandlerIgnoreExecInfo
 from PyEmailerAJM.msg import Msg
 
 

{pyemailerajm-1.9.2 → pyemailerajm-1.9.3}/PyEmailerAJM/continuous_monitor/backend/continuous_monitor_base.py

@@ -75,13 +75,50 @@ class ContinuousMonitorBase(PyEmailer, EmailState):
                 continue
             raise ValueError(f"{c} must be a list of email addresses")
 
+    def _normalize_logger(self, **kwargs):
+        # Normalize logger: if it's a factory, call it to get the instance
+        logger_arg = kwargs.pop('logger', self.logger)
+        if callable(logger_arg) and not hasattr(logger_arg, 'info'):
+            # It's a factory, not a logger instance
+            logger = logger_arg()
+        else:
+            logger = logger_arg
+        return logger
+
     def initialize_helper_classes(self, **kwargs):
-        colorizer = ContinuousColorizer(logger=self.logger)
-        snooze_tracker = SnoozeTracking(
-            Path(kwargs.get('file_name', './snooze_tracker.json')),
-            logger=self.logger,
-        )
-        sleep_timer = TheSandman(sleep_time_seconds=kwargs.get('sleep_time_seconds', None), logger=self.logger)
+        """
+        Initializes and returns instances of helper classes based on provided parameters.
+
+        This method is responsible for creating and configuring instances of helper
+        classes. It extracts configuration from the provided keyword arguments, uses
+        default class constructors when not overridden, and ensures logging and other
+        options are properly normalized and propagated.
+
+        :param kwargs: Configuration and initialization parameters for helper classes.
+        :type kwargs: dict
+        :return: A tuple containing instances of colorizer, snooze_tracker, and
+                 sleep_timer in that order.
+        :rtype: tuple
+        """
+        logger = self._normalize_logger(**kwargs)
+        # Remove old logger from kwargs after normalization
+        kwargs.pop('logger', None)
+
+        # Extract helper class factories with defaults
+        colorizer_class = kwargs.pop('colorizer', ContinuousColorizer)
+        snooze_tracker_class = kwargs.pop('snooze_tracker', SnoozeTracking)
+        sleep_timer_class = kwargs.pop('sleep_timer', TheSandman)
+
+        # Initialize helper instances
+        colorizer = colorizer_class(logger=logger, **kwargs)
+
+        snooze_file_path = Path(kwargs.pop('file_name', './snooze_tracker.json'))
+        snooze_tracker = snooze_tracker_class(file_path=snooze_file_path, logger=logger, **kwargs)
+
+        sleep_time_seconds = kwargs.pop('sleep_time_seconds', None)
+        sleep_timer = sleep_timer_class(sleep_time_seconds=sleep_time_seconds,
+                                        logger=logger, **kwargs)
+
         return colorizer, snooze_tracker, sleep_timer
 
     def log_dev_mode_warnings(self):
@@ -92,24 +129,38 @@ class ContinuousMonitorBase(PyEmailer, EmailState):
                 f" it will mock send emails but not actually send them to {self.__class__.ADMIN_EMAIL}"
             )
 
+    def _is_continuous_monitor_alert_send_subclass(self):
+        """Check if this instance is a ContinuousMonitorAlertSend subclass."""
+        is_named_match = type(self).__name__ == "ContinuousMonitorAlertSend"
+        is_dynamic_match = is_instance_of_dynamic(self, "__main__.ContinuousMonitorAlertSend")
+        return is_named_match or is_dynamic_match
+
+    def _should_skip_email_handler_init(self):
+        """Determine if email handler initialization should be skipped."""
+        if self.dev_mode:
+            self.logger.warning("email handler disabled for dev mode")
+            return True
+
+        if not self._is_continuous_monitor_alert_send_subclass():
+            self.logger.warning(
+                "email handler not initialized because this is not a "
+                "ContinuousMonitorAlertSend subclass"
+            )
+            return True
+
+        return False
+
     # Issue with PyEmailer 1.8.5 causes the base version to disable email handler
     #  (issue with check for setup_email_handler attr) - below is a functional work around
-    # TODO: allow the logger_class to be passed in as an arg
     def email_handler_init(self, **kwargs):
         logger_class = kwargs.get('logger_class', self.logger_class)
         try:
-            if self.dev_mode:
-                self.logger.warning("email handler disabled for dev mode")
-            elif (not type(self).__name__ == "ContinuousMonitorAlertSend"
-                  and not is_instance_of_dynamic(self, "__main__.ContinuousMonitorAlertSend")):
-                self.logger.warning(
-                    f"email handler not initialized because this is not a ContinuousMonitorAlertSend subclass"
-                )
-            else:
-                logger_class.setup_email_handler(email_msg=self.email,
-                                                 logger_admins=self.__class__.ADMIN_EMAIL_LOGGER)
-                self.email = self.initialize_new_email()
-                self.logger.info("email handler initialized, initialized a new email object for use by monitor")
+            if self._should_skip_email_handler_init():
+                return
+            logger_class.setup_email_handler(email_msg=self.email,
+                                             logger_admins=self.__class__.ADMIN_EMAIL_LOGGER)
+            self.email = self.initialize_new_email()
+            self.logger.info("email handler initialized, initialized a new email object for use by monitor")
         except AttributeError as e:
             self.logger.error(f"email handler not initialized because {e}")
             pass

{pyemailerajm-1.9.2 → pyemailerajm-1.9.3}/PyEmailerAJM/continuous_monitor/continuous_monitor.py

@@ -41,6 +41,25 @@ class ContinuousMonitor(ContinuousMonitorBase):
     def _postprocess_alert(self, alert_level=None, **kwargs):
         ...
 
+    def _process_no_alert(self, **kwargs):
+        no_alert_str = kwargs.get('no_alert_string',
+                                  self.__class__.NO_ALERTS_STR.format(read_folder=self.read_folder,
+                                                                      num_snoozed=self.num_snoozed_msgs))
+        self.logger.info(no_alert_str, print_msg=True)
+
+    def _classify_and_process(self, **kwargs):
+        if self.has_overdue:
+            self._print_and_postprocess(AlertTypes.OVERDUE)
+
+        elif self.has_warning:
+            self._print_and_postprocess(AlertTypes.WARNING)
+
+        elif self.has_critical_warning:
+            self._print_and_postprocess(AlertTypes.CRITICAL_WARNING)
+
+        else:
+            self._process_no_alert(**kwargs)
+
     # TODO: make no_alerts_string property so there is more flexibility with format
     def check_for_alerts(self, **kwargs):
         """
@@ -56,20 +75,7 @@ class ContinuousMonitor(ContinuousMonitorBase):
         self.logger.info(alert_check_string, print_msg=True)
         self.refresh_messages()
 
-        if self.has_overdue:
-            self._print_and_postprocess(AlertTypes.OVERDUE)
-
-        elif self.has_warning:
-            self._print_and_postprocess(AlertTypes.WARNING)
-
-        elif self.has_critical_warning:
-            self._print_and_postprocess(AlertTypes.CRITICAL_WARNING)
-
-        else:
-            no_alert_str = kwargs.get('no_alert_string',
-                                      self.__class__.NO_ALERTS_STR.format(read_folder=self.read_folder,
-                                                                          num_snoozed=self.num_snoozed_msgs))
-            self.logger.info(no_alert_str, print_msg=True)
+        self._classify_and_process(**kwargs)
 
         self.snooze_tracker.snooze_msgs(self.all_messages)
 

{pyemailerajm-1.9.2 → pyemailerajm-1.9.3}/PyEmailerAJM.egg-info/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: PyEmailerAJM
-Version: 1.9.2
+Version: 1.9.3
 Summary: Allows for automating sending Email with the Outlook Desktop client. Future releases will add more client support
 Home-page: https://github.com/amcsparron2793-Water/PyEmailer
-Download-URL: https://github.com/amcsparron2793-Water/PyEmailer/archive/refs/tags/1.9.2.tar.gz
+Download-URL: https://github.com/amcsparron2793-Water/PyEmailer/archive/refs/tags/1.9.3.tar.gz
 Author: Amcsparron
 Author-email: amcsparron@albanyny.gov
 License: MIT License

pyemailerajm-1.9.3/tests/test_continuous_monitor_base.py

@@ -0,0 +1,228 @@
+import unittest
+from unittest.mock import patch, MagicMock
+import logging
+from pathlib import Path
+
+from PyEmailerAJM.continuous_monitor.backend import ContinuousMonitorBase
+
+
+class DummyMonitor(ContinuousMonitorBase):
+    def _postprocess_alert(self, alert_level=None, **kwargs):
+        # Mark that postprocess was called
+        self.postprocess_called = True
+
+
+# Make DummyMonitor look like ContinuousMonitorAlertSend for the type check
+class ContinuousMonitorAlertSend(ContinuousMonitorBase):
+    """Mock subclass that passes the type check in email_handler_init"""
+
+    def _postprocess_alert(self, alert_level=None, **kwargs):
+        self.postprocess_called = True
+
+
+class DummyLoggerFactory:
+    """Callable logger factory with optional setup_email_handler capability"""
+
+    def __init__(self, with_email_handler=False):
+        self.with_email_handler = with_email_handler
+        self._last_kwargs = None
+
+    def __call__(self):
+        # Return a real Logger-like mock
+        mock_logger = MagicMock(spec=logging.Logger)
+        mock_logger.hasHandlers.return_value = False
+        mock_logger.handlers = []
+        return mock_logger
+
+    def setup_email_handler(self, **kwargs):
+        # record kwargs for assertion
+        self._last_kwargs = kwargs
+
+
+# Dummy helper classes for initialize_helper_classes behavior checks
+class DummyColorizer:
+    def __init__(self, logger=None, **kwargs):
+        self.logger = logger
+        self.kwargs = kwargs
+
+
+class DummySnoozeTracker:
+    def __init__(self, file_path: Path, logger=None, **kwargs):
+        self.file_path = file_path
+        self.logger = logger
+        self.kwargs = kwargs
+        # default internal state for snooze json
+        self.json_loaded = []
+
+
+class DummySleepTimer:
+    def __init__(self, sleep_time_seconds=None, logger=None, **kwargs):
+        self.sleep_time_seconds = sleep_time_seconds
+        self.logger = logger
+        self.kwargs = kwargs
+
+
+class TestContinuousMonitorBase(unittest.TestCase):
+    def setUp(self) -> None:
+        # Avoid actual COM/Outlook initialization
+        self._init_email_patch = patch(
+            'PyEmailerAJM.py_emailer_ajm.EmailerInitializer.initialize_email_item_app_and_namespace',
+            return_value=(None, None, MagicMock())
+        )
+        self._init_email_patch.start()
+
+        # Prevent EasyLogger from emitting during initialization
+        from EasyLoggerAJM.easy_logger import EasyLogger
+        self._post_handler_patcher = patch.object(EasyLogger, 'post_handler_setup', autospec=True)
+        self._post_handler_patcher.start()
+
+        # Provide logger factories used by tests
+        self.LoggerFactoryNoEmail = DummyLoggerFactory(with_email_handler=False)
+        self.LoggerFactoryWithEmail = DummyLoggerFactory(with_email_handler=True)
+
+    def tearDown(self) -> None:
+        self._post_handler_patcher.stop()
+        self._init_email_patch.stop()
+
+    def test_dev_mode_logs_and_disables_email_handler(self):
+        monitor = DummyMonitor(display_window=False, send_emails=False, dev_mode=True, logger=self.LoggerFactoryNoEmail)
+
+        # Expect dev mode warnings
+        logger = monitor.logger
+        calls = [c.args[0] for c in logger.warning.call_args_list]
+        self.assertTrue(any('DEV MODE ACTIVATED!' in msg for msg in calls))
+        self.assertTrue(any('email handler disabled for dev mode' in msg for msg in calls))
+
+    def test_skips_email_handler_when_not_alert_send_subclass(self):
+        monitor = DummyMonitor(display_window=False, send_emails=False, dev_mode=False,
+                               logger=self.LoggerFactoryNoEmail)
+
+        # Should warn that email handler not initialized because not subclass
+        logger = monitor.logger
+        warning_calls = [c.args[0] for c in logger.warning.call_args_list]
+        self.assertTrue(
+            any('not initialized because this is not a ContinuousMonitorAlertSend' in msg for msg in warning_calls))
+
+    def test_print_and_postprocess_calls_postprocess_when_not_dev(self):
+        monitor = DummyMonitor(display_window=False, send_emails=False, dev_mode=False,
+                               logger=self.LoggerFactoryNoEmail)
+        monitor.postprocess_called = False
+        monitor._print_and_postprocess(alert_level='INFO')
+        self.assertTrue(monitor.postprocess_called)
+
+    def test_print_and_postprocess_skips_postprocess_in_dev(self):
+        monitor = DummyMonitor(display_window=False, send_emails=False, dev_mode=True, logger=self.LoggerFactoryNoEmail)
+        monitor.postprocess_called = False
+        monitor._print_and_postprocess(alert_level='INFO')
+        self.assertFalse(monitor.postprocess_called)
+
+    def test_initializes_email_handler_when_factory_supports_it(self):
+        # Patch fresh email creation to a sentinel value and verify it gets set
+        with patch('PyEmailerAJM.py_emailer_ajm.EmailerInitializer.initialize_new_email', return_value='NEW_EMAIL'):
+            # Use ContinuousMonitorAlertSend instead of DummyMonitor to pass the type check
+            monitor = ContinuousMonitorAlertSend(display_window=False, send_emails=False, dev_mode=False,
+                                                 logger=self.LoggerFactoryWithEmail)
+        # Logger factory should have been used to setup email handler with original email
+        self.assertIsNotNone(self.LoggerFactoryWithEmail._last_kwargs)
+        self.assertIn('email_msg', self.LoggerFactoryWithEmail._last_kwargs)
+        # After init, email should be replaced with NEW_EMAIL
+        self.assertEqual(monitor.email, 'NEW_EMAIL')
+
+    def test_email_handler_init_handles_attribute_error(self):
+        # When logger_class lacks setup_email_handler, should be caught and not raise
+        monitor = ContinuousMonitorAlertSend(display_window=False, send_emails=False, dev_mode=False,
+                                             logger=self.LoggerFactoryWithEmail)
+        # Use a dummy object without setup_email_handler to trigger AttributeError
+        monitor.email_handler_init(logger_class=object())
+        # Ensure an error was logged
+        error_calls = [c.args[0] for c in monitor.logger.error.call_args_list]
+        self.assertTrue(any('email handler not initialized because' in msg for msg in error_calls))
+
+    def test_is_continuous_monitor_alert_send_subclass(self):
+        a = DummyMonitor(display_window=False, send_emails=False, dev_mode=False, logger=self.LoggerFactoryNoEmail)
+        b = ContinuousMonitorAlertSend(display_window=False, send_emails=False, dev_mode=False,
+                                       logger=self.LoggerFactoryNoEmail)
+        self.assertFalse(a._is_continuous_monitor_alert_send_subclass())
+        self.assertTrue(b._is_continuous_monitor_alert_send_subclass())
+
+    def test_should_skip_email_handler_init_paths(self):
+        # dev mode skips
+        m1 = ContinuousMonitorAlertSend(display_window=False, send_emails=False, dev_mode=True,
+                                        logger=self.LoggerFactoryNoEmail)
+        self.assertTrue(m1._should_skip_email_handler_init())
+        # not subclass skips
+        m2 = DummyMonitor(display_window=False, send_emails=False, dev_mode=False, logger=self.LoggerFactoryNoEmail)
+        self.assertTrue(m2._should_skip_email_handler_init())
+        # valid subclass and not dev mode does not skip
+        m3 = ContinuousMonitorAlertSend(display_window=False, send_emails=False, dev_mode=False,
+                                        logger=self.LoggerFactoryNoEmail)
+        self.assertFalse(m3._should_skip_email_handler_init())
+
+    def test_normalize_logger_with_factory_and_instance(self):
+        # Using factory returns a logger instance
+        m = DummyMonitor(display_window=False, send_emails=False, dev_mode=False, logger=self.LoggerFactoryNoEmail)
+        l_from_factory = m._normalize_logger(logger=self.LoggerFactoryNoEmail)
+        self.assertTrue(hasattr(l_from_factory, 'info'))
+        # Using instance returns the same instance
+        logger_instance = MagicMock(spec=logging.Logger)
+        l_from_instance = m._normalize_logger(logger=logger_instance)
+        self.assertIs(l_from_instance, logger_instance)
+        # Not providing logger uses self.logger
+        l_default = m._normalize_logger()
+        self.assertIs(l_default, m.logger)
+
+    def test_initialize_helper_classes_and_num_snoozed_msgs(self):
+        m = DummyMonitor(display_window=False, send_emails=False, dev_mode=False, logger=self.LoggerFactoryNoEmail)
+        colorizer, snoozer, sleeper = m.initialize_helper_classes(
+            colorizer=DummyColorizer,
+            snooze_tracker=DummySnoozeTracker,
+            sleep_timer=DummySleepTimer,
+            file_name='my_snooze.json',
+            sleep_time_seconds=42,
+            extra_opt=123
+        )
+        # helper types
+        self.assertIsInstance(colorizer, DummyColorizer)
+        self.assertIsInstance(snoozer, DummySnoozeTracker)
+        self.assertIsInstance(sleeper, DummySleepTimer)
+        # logger propagated
+        self.assertIs(colorizer.logger, m.logger)
+        self.assertIs(snoozer.logger, m.logger)
+        self.assertIs(sleeper.logger, m.logger)
+        # file path and sleep time propagated and processed
+        self.assertTrue(str(snoozer.file_path).endswith('my_snooze.json'))
+        self.assertEqual(sleeper.sleep_time_seconds, 42)
+        # extra options should pass to colorizer and snoozer and sleeper
+        self.assertEqual(colorizer.kwargs.get('extra_opt'), 123)
+        self.assertEqual(snoozer.kwargs.get('extra_opt'), 123)
+        self.assertEqual(sleeper.kwargs.get('extra_opt'), 123)
+        # Verify num_snoozed_msgs reflects json_loaded length
+        m.snooze_tracker = snoozer
+        snoozer.json_loaded = [1, 2, 3]
+        self.assertEqual(m.num_snoozed_msgs, 3)
+        # When no json_loaded or not sized, expect 0
+        snoozer.json_loaded = None
+        self.assertEqual(m.num_snoozed_msgs, 0)
+
+    def test_check_for_class_attrs(self):
+        class GoodSub(ContinuousMonitorBase):
+            ADMIN_EMAIL = ['a@example.com']
+
+            def _postprocess_alert(self, alert_level=None, **kwargs):
+                pass
+
+        class BadSub(ContinuousMonitorBase):
+            ADMIN_EMAIL = []
+
+            def _postprocess_alert(self, alert_level=None, **kwargs):
+                pass
+
+        # Good should not raise
+        GoodSub.check_for_class_attrs(['ADMIN_EMAIL'])
+        # Bad should raise
+        with self.assertRaises(ValueError):
+            BadSub.check_for_class_attrs(['ADMIN_EMAIL'])
+
+
+if __name__ == '__main__':
+    unittest.main()

pyemailerajm-1.9.2/PyEmailerAJM/_version.py

@@ -1 +0,0 @@
-__version__ = '1.9.2'

pyemailerajm-1.9.2/tests/test_continuous_monitor_base.py

@@ -1,104 +0,0 @@
-import unittest
-from unittest.mock import patch, MagicMock
-import logging
-
-from PyEmailerAJM.continuous_monitor.backend import ContinuousMonitorBase
-
-
-class DummyMonitor(ContinuousMonitorBase):
-    def _postprocess_alert(self, alert_level=None, **kwargs):
-        # Mark that postprocess was called
-        self.postprocess_called = True
-
-
-# Make DummyMonitor look like ContinuousMonitorAlertSend for the type check
-class ContinuousMonitorAlertSend(ContinuousMonitorBase):
-    """Mock subclass that passes the type check in email_handler_init"""
-    def _postprocess_alert(self, alert_level=None, **kwargs):
-        self.postprocess_called = True
-
-
-class DummyLoggerFactory:
-    """Callable logger factory with optional setup_email_handler capability"""
-    def __init__(self, with_email_handler=False):
-        self.with_email_handler = with_email_handler
-        self._last_kwargs = None
-
-    def __call__(self):
-        # Return a real Logger-like mock
-        mock_logger = MagicMock(spec=logging.Logger)
-        mock_logger.hasHandlers.return_value = False
-        mock_logger.handlers = []
-        return mock_logger
-
-    def setup_email_handler(self, **kwargs):
-        # record kwargs for assertion
-        self._last_kwargs = kwargs
-
-
-class TestContinuousMonitorBase(unittest.TestCase):
-    def setUp(self) -> None:
-        # Avoid actual COM/Outlook initialization
-        self._init_email_patch = patch(
-            'PyEmailerAJM.py_emailer_ajm.EmailerInitializer.initialize_email_item_app_and_namespace',
-            return_value=(None, None, MagicMock())
-        )
-        self._init_email_patch.start()
-
-        # Prevent EasyLogger from emitting during initialization
-        from EasyLoggerAJM.easy_logger import EasyLogger
-        self._post_handler_patcher = patch.object(EasyLogger, 'post_handler_setup', autospec=True)
-        self._post_handler_patcher.start()
-
-        # Provide logger factories used by tests
-        self.LoggerFactoryNoEmail = DummyLoggerFactory(with_email_handler=False)
-        self.LoggerFactoryWithEmail = DummyLoggerFactory(with_email_handler=True)
-
-    def tearDown(self) -> None:
-        self._post_handler_patcher.stop()
-        self._init_email_patch.stop()
-
-    def test_dev_mode_logs_and_disables_email_handler(self):
-        monitor = DummyMonitor(display_window=False, send_emails=False, dev_mode=True, logger=self.LoggerFactoryNoEmail)
-
-        # Expect dev mode warnings
-        logger = monitor.logger
-        calls = [c.args[0] for c in logger.warning.call_args_list]
-        self.assertTrue(any('DEV MODE ACTIVATED!' in msg for msg in calls))
-        self.assertTrue(any('email handler disabled for dev mode' in msg for msg in calls))
-
-    def test_skips_email_handler_when_logger_factory_has_no_setup(self):
-        monitor = DummyMonitor(display_window=False, send_emails=False, dev_mode=False, logger=self.LoggerFactoryNoEmail)
-
-        # Should debug that email handler not initialized due to lack of capability
-        logger = monitor.logger
-        warning_calls = [c.args[0] for c in logger.warning.call_args_list]
-        self.assertTrue(any('not initialized because this is not a ContinuousMonitorAlertSend' in msg for msg in warning_calls))
-
-    def test_print_and_postprocess_calls_postprocess_when_not_dev(self):
-        monitor = DummyMonitor(display_window=False, send_emails=False, dev_mode=False, logger=self.LoggerFactoryNoEmail)
-        monitor.postprocess_called = False
-        monitor._print_and_postprocess(alert_level='INFO')
-        self.assertTrue(monitor.postprocess_called)
-
-    def test_print_and_postprocess_skips_postprocess_in_dev(self):
-        monitor = DummyMonitor(display_window=False, send_emails=False, dev_mode=True, logger=self.LoggerFactoryNoEmail)
-        monitor.postprocess_called = False
-        monitor._print_and_postprocess(alert_level='INFO')
-        self.assertFalse(monitor.postprocess_called)
-
-    def test_initializes_email_handler_when_factory_supports_it(self):
-        # Patch fresh email creation to a sentinel value and verify it gets set
-        with patch('PyEmailerAJM.py_emailer_ajm.EmailerInitializer.initialize_new_email', return_value='NEW_EMAIL'):
-            # Use ContinuousMonitorAlertSend instead of DummyMonitor to pass the type check
-            monitor = ContinuousMonitorAlertSend(display_window=False, send_emails=False, dev_mode=False,
-                                   logger=self.LoggerFactoryWithEmail)
-        # Logger factory should have been used to setup email handler with original email
-        self.assertIsNotNone(self.LoggerFactoryWithEmail._last_kwargs)
-        self.assertIn('email_msg', self.LoggerFactoryWithEmail._last_kwargs)
-        # After init, email should be replaced with NEW_EMAIL
-        self.assertEqual(monitor.email, 'NEW_EMAIL')
-
-
-if __name__ == '__main__':
-    unittest.main()