Fix notification flow by removing backwards dependency chain (#553) (#571)

Replace the 4-layer notify_scrape_exception() chain with a forward-only
flow where the coordinator owns a _force_reauth flag and passes it to
ContentRequestManager.get_content() at request time.

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: danieldotnl

custom_components/multiscrape/binary_sensor.py

@@ -151,7 +151,7 @@ def _update_sensor(self):
                 self._attr_is_on,
             )
         except Exception as exception:
-            self.coordinator.notify_scrape_exception()
+            self.coordinator.request_reauth()
 
             if self._sensor_selector.on_error.log not in [False, "false", "False"]:
                 level = LOG_LEVELS[self._sensor_selector.on_error.log]

custom_components/multiscrape/coordinator.py

@@ -54,12 +54,11 @@ def __init__(
         self._session = session
         self._resource_renderer = resource_renderer
 
-    def notify_scrape_exception(self):
-        """Notify the session of an exception so it will re-submit next trigger."""
-        self._session.notify_scrape_exception()
-
-    async def get_content(self) -> str:
+    async def get_content(self, force_reauth: bool = False) -> str:
         """Retrieve the content of a url and first submit a form if required."""
+        if force_reauth:
+            self._session.invalidate_auth()
+
         resource = self._resource_renderer()
 
         try:
@@ -128,6 +127,7 @@ def __init__(
         self.update_error = False
         self._resource = None
         self._retry_count: int = 0
+        self._force_reauth: bool = False
 
         if self._update_interval == timedelta(seconds=0):
             self._update_interval = None
@@ -155,15 +155,18 @@ async def _on_hass_start(_: Event) -> None:
 
         hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STARTED, _on_hass_start)
 
-    def notify_scrape_exception(self) -> None:
-        """Notify the ContentRequestManager of a scrape exception so it can notify the FormSubmitter."""
-        self._request_manager.notify_scrape_exception()
+    def request_reauth(self) -> None:
+        """Flag that re-authentication is needed on the next update cycle."""
+        self._force_reauth = True
 
     async def _async_update_data(self) -> None:
         await self._prepare_new_run()
 
         try:
-            response = await self._request_manager.get_content()
+            response = await self._request_manager.get_content(
+                force_reauth=self._force_reauth
+            )
+            self._force_reauth = False
             await self._scraper.set_content(response)
             _LOGGER.debug(
                 "%s # Data successfully refreshed. Sensors will now start scraping to update.",
@@ -172,6 +175,7 @@ async def _async_update_data(self) -> None:
             self._retry_count = 0
 
         except Exception as ex:
+            self._force_reauth = True
             _LOGGER.error(
                 "%s # Updating failed with exception: %s",
                 self._config_name,

custom_components/multiscrape/form_auth.py

@@ -140,11 +140,11 @@ async def ensure_authenticated(self, main_resource: str) -> str | None:
             return response.text
         return None
 
-    def notify_scrape_exception(self):
-        """Re-submit form after a scrape exception if configured."""
+    def invalidate(self):
+        """Mark session as invalid so the form will be re-submitted next interval."""
         if self._config.resubmit_on_error:
             _LOGGER.debug(
-                "%s # Exception occurred while scraping, will try to resubmit the form next interval.",
+                "%s # Session invalidated, will re-submit the form next interval.",
                 self._config_name,
             )
             self._should_submit = True

custom_components/multiscrape/http_session.py

@@ -214,10 +214,10 @@ async def ensure_authenticated(self, main_resource: str) -> str | None:
             return None
         return await self._form_authenticator.ensure_authenticated(main_resource)
 
-    def notify_scrape_exception(self):
-        """Re-submit form after a scrape exception if configured."""
+    def invalidate_auth(self):
+        """Invalidate the current authentication so the form will be re-submitted."""
         if self._form_authenticator:
-            self._form_authenticator.notify_scrape_exception()
+            self._form_authenticator.invalidate()
 
     @property
     def form_variables(self) -> dict[str, Any]:

custom_components/multiscrape/sensor.py

@@ -153,7 +153,7 @@ def _update_sensor(self):
                     value, self.entity_id, self.device_class
                 )
         except Exception as exception:
-            self.coordinator.notify_scrape_exception()
+            self.coordinator.request_reauth()
 
             if self._sensor_selector.on_error.log not in [False, "false", "False"]:
                 level = LOG_LEVELS[self._sensor_selector.on_error.log]

tests/conftest.py

@@ -104,7 +104,7 @@ def mock_http_session(mock_http_response):
     ))
     mock.ensure_authenticated = AsyncMock(return_value=None)
     mock.form_variables = {}
-    mock.notify_scrape_exception = MagicMock()
+    mock.invalidate_auth = MagicMock()
     mock.async_close = AsyncMock()
     return mock
 

tests/test_coordinator.py

@@ -42,7 +42,7 @@ async def test_content_request_manager_with_form_submission(
         return_value="<html>Form Response</html>"
     )
     mock_session.form_variables = {"var": "value"}
-    mock_session.notify_scrape_exception = MagicMock()
+    mock_session.invalidate_auth = MagicMock()
     mock_session.async_request = AsyncMock()
 
     manager = ContentRequestManager(
@@ -72,7 +72,7 @@ async def test_content_request_manager_form_submission_no_result(
     mock_session = AsyncMock()
     mock_session.ensure_authenticated = AsyncMock(return_value=None)
     mock_session.form_variables = {"var": "value"}
-    mock_session.notify_scrape_exception = MagicMock()
+    mock_session.invalidate_auth = MagicMock()
     mock_session.async_request = AsyncMock(
         return_value=mock_http_response(text="<html>Page Content</html>")
     )
@@ -128,15 +128,35 @@ async def test_coordinator_update_failure(coordinator, mock_http_session):
 @pytest.mark.unit
 @pytest.mark.async_test
 @pytest.mark.timeout(5)
-async def test_coordinator_notify_scrape_exception(
+async def test_coordinator_request_reauth(
     coordinator, mock_http_session
 ):
-    """Test that scrape exceptions are properly notified."""
+    """Test that request_reauth sets the force_reauth flag."""
     # Act
-    coordinator.notify_scrape_exception()
+    coordinator.request_reauth()
 
     # Assert
-    mock_http_session.notify_scrape_exception.assert_called_once()
+    assert coordinator._force_reauth is True
+
+
+@pytest.mark.integration
+@pytest.mark.async_test
+@pytest.mark.timeout(10)
+async def test_coordinator_force_reauth_lifecycle(
+    coordinator, mock_http_session
+):
+    """Verify full flag lifecycle: request_reauth -> pass force_reauth -> invalidate_auth -> reset."""
+    # Simulate entity reporting a scrape exception
+    coordinator.request_reauth()
+    assert coordinator._force_reauth is True
+
+    # Next update should pass force_reauth=True, then reset the flag
+    await coordinator._async_update_data()
+
+    # invalidate_auth should have been called (via ContentRequestManager.get_content)
+    mock_http_session.invalidate_auth.assert_called_once()
+    # Flag should be reset after successful update
+    assert coordinator._force_reauth is False
 
 
 @pytest.mark.integration

tests/test_http_session.py

@@ -510,8 +510,8 @@ async def test_form_auth_resubmit_on_error(hass: HomeAssistant):
     await sess.ensure_authenticated("https://example.com/main")
     assert not sess._form_authenticator._should_submit
 
-    # Notify scrape exception
-    sess.notify_scrape_exception()
+    # Invalidate auth (simulating coordinator passing force_reauth)
+    sess.invalidate_auth()
     assert sess._form_authenticator._should_submit
 
     # Now it should submit again
@@ -763,19 +763,19 @@ def test_no_form_auth_returns_empty_variables(session):
 
 
 @pytest.mark.unit
-def test_notify_scrape_exception_without_form(session):
-    """Test notify_scrape_exception is a no-op without form auth."""
+def test_invalidate_auth_without_form(session):
+    """Test invalidate_auth is a no-op without form auth."""
     # Should not raise
-    session.notify_scrape_exception()
+    session.invalidate_auth()
 
 
 @pytest.mark.unit
-def test_notify_scrape_exception_resubmit_disabled(hass: HomeAssistant):
-    """Test notify_scrape_exception does nothing when resubmit_on_error is False."""
+def test_invalidate_auth_resubmit_disabled(hass: HomeAssistant):
+    """Test invalidate_auth does nothing when resubmit_on_error is False."""
     form_config = make_form_config(resubmit_on_error=False)
     sess = make_form_session(hass, form_config)
     sess._form_authenticator._should_submit = False
-    sess.notify_scrape_exception()
+    sess.invalidate_auth()
     assert not sess._form_authenticator._should_submit
 
 
@@ -1140,11 +1140,8 @@ async def test_e2e_form_resubmit_on_error(hass: HomeAssistant):
         await request_manager.get_content()
         assert login_route.call_count == 1
 
-        # Simulate scrape exception notification
-        request_manager.notify_scrape_exception()
-
-        # Third call — form re-submits after error
-        await request_manager.get_content()
+        # Simulate coordinator passing force_reauth after scrape exception
+        await request_manager.get_content(force_reauth=True)
         assert login_route.call_count == 2
     finally:
         await session.async_close()
@@ -1704,15 +1701,12 @@ async def test_e2e_form_variables_updated_on_resubmit(hass: HomeAssistant):
         await request_manager.get_content()
         assert session.form_variables["api_token"] == "token_v1"
 
-        # Trigger resubmit
-        request_manager.notify_scrape_exception()
-
         # Second auth returns token_v2
         submit_route.mock(
             return_value=respx.MockResponse(200, text=FORM_RESPONSE_V2)
         )
 
-        await request_manager.get_content()
+        await request_manager.get_content(force_reauth=True)
         assert session.form_variables["api_token"] == "token_v2"
     finally:
         await session.async_close()