Use start_reauth helper method in integration tests (m-o) (#124790)

tests/components/mealie/test_config_flow.py

@@ -6,7 +6,7 @@ from aiomealie import About, MealieAuthenticationError, MealieConnectionError
 import pytest
 
 from homeassistant.components.mealie.const import DOMAIN
-from homeassistant.config_entries import SOURCE_REAUTH, SOURCE_RECONFIGURE, SOURCE_USER
+from homeassistant.config_entries import SOURCE_RECONFIGURE, SOURCE_USER
 from homeassistant.const import CONF_API_TOKEN, CONF_HOST, CONF_VERIFY_SSL
 from homeassistant.core import HomeAssistant
 from homeassistant.data_entry_flow import FlowResultType
@@ -152,11 +152,7 @@ async def test_reauth_flow(
     """Test reauth flow."""
     await setup_integration(hass, mock_config_entry)
 
-    result = await hass.config_entries.flow.async_init(
+    result = await mock_config_entry.start_reauth_flow(hass)
-        DOMAIN,
-        context={"source": SOURCE_REAUTH, "entry_id": mock_config_entry.entry_id},
-        data=mock_config_entry.data,
-    )
     assert result["type"] is FlowResultType.FORM
     assert result["step_id"] == "reauth_confirm"
 
@@ -179,11 +175,7 @@ async def test_reauth_flow_wrong_account(
     """Test reauth flow with wrong account."""
     await setup_integration(hass, mock_config_entry)
 
-    result = await hass.config_entries.flow.async_init(
+    result = await mock_config_entry.start_reauth_flow(hass)
-        DOMAIN,
-        context={"source": SOURCE_REAUTH, "entry_id": mock_config_entry.entry_id},
-        data=mock_config_entry.data,
-    )
     assert result["type"] is FlowResultType.FORM
     assert result["step_id"] == "reauth_confirm"
 
@@ -218,11 +210,7 @@ async def test_reauth_flow_exceptions(
     await setup_integration(hass, mock_config_entry)
     mock_mealie_client.get_user_info.side_effect = exception
 
-    result = await hass.config_entries.flow.async_init(
+    result = await mock_config_entry.start_reauth_flow(hass)
-        DOMAIN,
-        context={"source": SOURCE_REAUTH, "entry_id": mock_config_entry.entry_id},
-        data=mock_config_entry.data,
-    )
     assert result["type"] is FlowResultType.FORM
     assert result["step_id"] == "reauth_confirm"
 

tests/components/meater/test_config_flow.py

@@ -123,11 +123,7 @@ async def test_reauth_flow(hass: HomeAssistant, mock_meater) -> None:
     )
     mock_config.add_to_hass(hass)
 
-    result = await hass.config_entries.flow.async_init(
+    result = await mock_config.start_reauth_flow(hass)
-        DOMAIN,
-        context={"source": config_entries.SOURCE_REAUTH},
-        data=data,
-    )
 
     assert result["type"] is FlowResultType.FORM
     assert result["step_id"] == "reauth_confirm"

tests/components/melcloud/test_config_flow.py

@@ -9,7 +9,7 @@ import pytest
 
 from homeassistant import config_entries
 from homeassistant.components.melcloud.const import DOMAIN
-from homeassistant.config_entries import SOURCE_REAUTH, SOURCE_RECONFIGURE
+from homeassistant.config_entries import SOURCE_RECONFIGURE
 from homeassistant.const import CONF_PASSWORD
 from homeassistant.core import HomeAssistant
 from homeassistant.data_entry_flow import FlowResultType
@@ -166,15 +166,7 @@ async def test_token_reauthentication(
     )
     mock_entry.add_to_hass(hass)
 
-    result = await hass.config_entries.flow.async_init(
+    result = await mock_entry.start_reauth_flow(hass)
-        DOMAIN,
-        context={
-            "source": SOURCE_REAUTH,
-            "unique_id": mock_entry.unique_id,
-            "entry_id": mock_entry.entry_id,
-        },
-        data=mock_entry.data,
-    )
     assert result["type"] is FlowResultType.FORM
     assert result["step_id"] == "reauth_confirm"
 
@@ -212,15 +204,7 @@ async def test_form_errors_reauthentication(
     )
     mock_entry.add_to_hass(hass)
 
-    result = await hass.config_entries.flow.async_init(
+    result = await mock_entry.start_reauth_flow(hass)
-        DOMAIN,
-        context={
-            "source": SOURCE_REAUTH,
-            "unique_id": mock_entry.unique_id,
-            "entry_id": mock_entry.entry_id,
-        },
-        data=mock_entry.data,
-    )
 
     with patch(
         "homeassistant.components.melcloud.async_setup_entry",
@@ -270,15 +254,7 @@ async def test_client_errors_reauthentication(
     )
     mock_entry.add_to_hass(hass)
 
-    result = await hass.config_entries.flow.async_init(
+    result = await mock_entry.start_reauth_flow(hass)
-        DOMAIN,
-        context={
-            "source": SOURCE_REAUTH,
-            "unique_id": mock_entry.unique_id,
-            "entry_id": mock_entry.entry_id,
-        },
-        data=mock_entry.data,
-    )
 
     with patch(
         "homeassistant.components.melcloud.async_setup_entry",

tests/components/microbees/test_config_flow.py

@@ -6,7 +6,7 @@ from microBeesPy import MicroBeesException
 import pytest
 
 from homeassistant.components.microbees.const import DOMAIN
-from homeassistant.config_entries import SOURCE_REAUTH, SOURCE_USER
+from homeassistant.config_entries import SOURCE_USER
 from homeassistant.core import HomeAssistant
 from homeassistant.data_entry_flow import FlowResultType
 from homeassistant.helpers import config_entry_oauth2_flow
@@ -144,14 +144,7 @@ async def test_config_reauth_profile(
     """Test reauth an existing profile reauthenticates the config entry."""
     await setup_integration(hass, config_entry)
 
-    result = await hass.config_entries.flow.async_init(
+    result = await config_entry.start_reauth_flow(hass)
-        DOMAIN,
-        context={
-            "source": SOURCE_REAUTH,
-            "entry_id": config_entry.entry_id,
-        },
-        data=config_entry.data,
-    )
     assert result["type"] is FlowResultType.FORM
     assert result["step_id"] == "reauth_confirm"
 
@@ -205,14 +198,7 @@ async def test_config_reauth_wrong_account(
     """Test reauth with wrong account."""
     await setup_integration(hass, config_entry)
     microbees.return_value.getMyProfile.return_value.id = 12345
-    result = await hass.config_entries.flow.async_init(
+    result = await config_entry.start_reauth_flow(hass)
-        DOMAIN,
-        context={
-            "source": SOURCE_REAUTH,
-            "entry_id": config_entry.entry_id,
-        },
-        data=config_entry.data,
-    )
     assert result["type"] is FlowResultType.FORM
     assert result["step_id"] == "reauth_confirm"
 

tests/components/mikrotik/test_config_flow.py

@@ -175,14 +175,7 @@ async def test_reauth_success(hass: HomeAssistant, api) -> None:
     )
     entry.add_to_hass(hass)
 
-    result = await hass.config_entries.flow.async_init(
+    result = await entry.start_reauth_flow(hass)
-        DOMAIN,
-        context={
-            "source": config_entries.SOURCE_REAUTH,
-            "entry_id": entry.entry_id,
-        },
-        data=DEMO_USER_INPUT,
-    )
 
     assert result["type"] is FlowResultType.FORM
     assert result["step_id"] == "reauth_confirm"
@@ -207,14 +200,7 @@ async def test_reauth_failed(hass: HomeAssistant, auth_error) -> None:
     )
     entry.add_to_hass(hass)
 
-    result = await hass.config_entries.flow.async_init(
+    result = await entry.start_reauth_flow(hass)
-        DOMAIN,
-        context={
-            "source": config_entries.SOURCE_REAUTH,
-            "entry_id": entry.entry_id,
-        },
-        data=DEMO_USER_INPUT,
-    )
 
     assert result["type"] is FlowResultType.FORM
     assert result["step_id"] == "reauth_confirm"
@@ -240,14 +226,7 @@ async def test_reauth_failed_conn_error(hass: HomeAssistant, conn_error) -> None
     )
     entry.add_to_hass(hass)
 
-    result = await hass.config_entries.flow.async_init(
+    result = await entry.start_reauth_flow(hass)
-        DOMAIN,
-        context={
-            "source": config_entries.SOURCE_REAUTH,
-            "entry_id": entry.entry_id,
-        },
-        data=DEMO_USER_INPUT,
-    )
 
     assert result["type"] is FlowResultType.FORM
     assert result["step_id"] == "reauth_confirm"

tests/components/monzo/test_config_flow.py

@@ -154,14 +154,7 @@ async def test_config_reauth_profile(
     """Test reauth an existing profile reauthenticates the config entry."""
     await setup_integration(hass, polling_config_entry)
 
-    result = await hass.config_entries.flow.async_init(
+    result = await polling_config_entry.start_reauth_flow(hass)
-        DOMAIN,
-        context={
-            "source": SOURCE_REAUTH,
-            "entry_id": polling_config_entry.entry_id,
-        },
-        data=polling_config_entry.data,
-    )
     assert result["type"] is FlowResultType.FORM
     assert result["step_id"] == "reauth_confirm"
 
@@ -223,14 +216,7 @@ async def test_config_reauth_wrong_account(
     """Test reauth with wrong account."""
     await setup_integration(hass, polling_config_entry)
 
-    result = await hass.config_entries.flow.async_init(
+    result = await polling_config_entry.start_reauth_flow(hass)
-        DOMAIN,
-        context={
-            "source": SOURCE_REAUTH,
-            "entry_id": polling_config_entry.entry_id,
-        },
-        data=polling_config_entry.data,
-    )
     assert result["type"] is FlowResultType.FORM
     assert result["step_id"] == "reauth_confirm"
 

tests/components/motioneye/test_config_flow.py

@@ -264,14 +264,7 @@ async def test_reauth(hass: HomeAssistant) -> None:
 
     config_entry = create_mock_motioneye_config_entry(hass, data=config_data)
 
-    result = await hass.config_entries.flow.async_init(
+    result = await config_entry.start_reauth_flow(hass)
-        DOMAIN,
-        context={
-            "source": config_entries.SOURCE_REAUTH,
-            "entry_id": config_entry.entry_id,
-        },
-        data=config_entry.data,
-    )
     assert result["type"] is FlowResultType.FORM
     assert not result["errors"]
 

tests/components/mqtt/test_config_flow.py

@@ -1551,14 +1551,7 @@ async def test_step_reauth(
     assert result["context"]["source"] == "reauth"
 
     # Show the form
-    result = await hass.config_entries.flow.async_init(
+    result = await config_entry.start_reauth_flow(hass)
-        mqtt.DOMAIN,
-        context={
-            "source": config_entries.SOURCE_REAUTH,
-            "entry_id": config_entry.entry_id,
-        },
-        data=config_entry.data,
-    )
     assert result["type"] is FlowResultType.FORM
     assert result["step_id"] == "reauth_confirm"
 

tests/components/myuplink/test_config_flow.py

@@ -105,14 +105,7 @@ async def test_flow_reauth(
 
     assert len(hass.config_entries.async_entries(DOMAIN)) == 1
 
-    result = await hass.config_entries.flow.async_init(
+    result = await mock_config_entry.start_reauth_flow(hass)
-        DOMAIN,
-        context={
-            "source": config_entries.SOURCE_REAUTH,
-            "entry_id": mock_config_entry.entry_id,
-        },
-        data=mock_config_entry.data,
-    )
 
     assert result["step_id"] == "reauth_confirm"
 

tests/components/nam/test_config_flow.py

@@ -9,7 +9,6 @@ import pytest
 from homeassistant.components import zeroconf
 from homeassistant.components.nam.const import DOMAIN
 from homeassistant.config_entries import (
-    SOURCE_REAUTH,
     SOURCE_RECONFIGURE,
     SOURCE_USER,
     SOURCE_ZEROCONF,
@@ -122,6 +121,9 @@ async def test_reauth_successful(hass: HomeAssistant) -> None:
         data={"host": "10.10.2.3"},
     )
     entry.add_to_hass(hass)
+    result = await entry.start_reauth_flow(hass)
+    assert result["type"] is FlowResultType.FORM
+    assert result["step_id"] == "reauth_confirm"
 
     with (
         patch(
@@ -133,15 +135,6 @@ async def test_reauth_successful(hass: HomeAssistant) -> None:
             return_value="aa:bb:cc:dd:ee:ff",
         ),
     ):
-        result = await hass.config_entries.flow.async_init(
-            DOMAIN,
-            context={"source": SOURCE_REAUTH, "entry_id": entry.entry_id},
-            data=entry.data,
-        )
-
-        assert result["type"] is FlowResultType.FORM
-        assert result["step_id"] == "reauth_confirm"
-
         result = await hass.config_entries.flow.async_configure(
             result["flow_id"],
             user_input=VALID_AUTH,
@@ -160,20 +153,14 @@ async def test_reauth_unsuccessful(hass: HomeAssistant) -> None:
         data={"host": "10.10.2.3"},
     )
     entry.add_to_hass(hass)
+    result = await entry.start_reauth_flow(hass)
+    assert result["type"] is FlowResultType.FORM
+    assert result["step_id"] == "reauth_confirm"
 
     with patch(
         "homeassistant.components.nam.NettigoAirMonitor.async_check_credentials",
         side_effect=ApiError("API Error"),
     ):
-        result = await hass.config_entries.flow.async_init(
-            DOMAIN,
-            context={"source": SOURCE_REAUTH, "entry_id": entry.entry_id},
-            data=entry.data,
-        )
-
-        assert result["type"] is FlowResultType.FORM
-        assert result["step_id"] == "reauth_confirm"
-
         result = await hass.config_entries.flow.async_configure(
             result["flow_id"],
             user_input=VALID_AUTH,

tests/components/nanoleaf/test_config_flow.py

@@ -297,15 +297,7 @@ async def test_reauth(hass: HomeAssistant) -> None:
             return_value=True,
         ),
     ):
-        result = await hass.config_entries.flow.async_init(
+        result = await entry.start_reauth_flow(hass)
-            DOMAIN,
-            context={
-                "source": config_entries.SOURCE_REAUTH,
-                "entry_id": entry.entry_id,
-                "unique_id": entry.unique_id,
-            },
-            data=entry.data,
-        )
         assert result["type"] is FlowResultType.FORM
         assert result["step_id"] == "link"
 

tests/components/neato/test_config_flow.py

@@ -111,16 +111,15 @@ async def test_reauth(
         hass, NEATO_DOMAIN, ClientCredential(CLIENT_ID, CLIENT_SECRET)
     )
 
-    MockConfigEntry(
+    entry = MockConfigEntry(
         entry_id="my_entry",
         domain=NEATO_DOMAIN,
         data={"username": "abcdef", "password": "123456", "vendor": "neato"},
-    ).add_to_hass(hass)
+    )
+    entry.add_to_hass(hass)
 
     # Should show form
-    result = await hass.config_entries.flow.async_init(
+    result = await entry.start_reauth_flow(hass)
-        "neato", context={"source": config_entries.SOURCE_REAUTH}
-    )
     assert result["type"] is FlowResultType.FORM
     assert result["step_id"] == "reauth_confirm"
 

tests/components/nextcloud/test_config_flow.py

@@ -11,7 +11,7 @@ import pytest
 from syrupy.assertion import SnapshotAssertion
 
 from homeassistant.components.nextcloud.const import DOMAIN
-from homeassistant.config_entries import SOURCE_REAUTH, SOURCE_USER
+from homeassistant.config_entries import SOURCE_USER
 from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
 from homeassistant.core import HomeAssistant
 from homeassistant.data_entry_flow import FlowResultType
@@ -135,11 +135,7 @@ async def test_reauth(hass: HomeAssistant, snapshot: SnapshotAssertion) -> None:
     entry.add_to_hass(hass)
 
     # start reauth flow
-    result = await hass.config_entries.flow.async_init(
+    result = await entry.start_reauth_flow(hass)
-        DOMAIN,
-        context={"source": SOURCE_REAUTH, "entry_id": entry.entry_id},
-        data=entry.data,
-    )
     assert result["type"] is FlowResultType.FORM
     assert result["step_id"] == "reauth_confirm"
 

tests/components/notion/test_config_flow.py

@@ -6,13 +6,15 @@ from aionotion.errors import InvalidCredentialsError, NotionError
 import pytest
 
 from homeassistant.components.notion import CONF_REFRESH_TOKEN, CONF_USER_UUID, DOMAIN
-from homeassistant.config_entries import SOURCE_REAUTH, SOURCE_USER
+from homeassistant.config_entries import SOURCE_USER
 from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
 from homeassistant.core import HomeAssistant
 from homeassistant.data_entry_flow import FlowResultType
 
 from .conftest import TEST_PASSWORD, TEST_REFRESH_TOKEN, TEST_USER_UUID, TEST_USERNAME
 
+from tests.common import MockConfigEntry
+
 pytestmark = pytest.mark.usefixtures("mock_setup_entry")
 
 
@@ -90,21 +92,13 @@ async def test_duplicate_error(hass: HomeAssistant, config, config_entry) -> Non
 async def test_reauth(
     hass: HomeAssistant,
     config,
-    config_entry,
+    config_entry: MockConfigEntry,
     errors,
     get_client_with_exception,
     mock_aionotion,
 ) -> None:
     """Test that re-auth works."""
-    result = await hass.config_entries.flow.async_init(
+    result = await config_entry.start_reauth_flow(hass)
-        DOMAIN,
-        context={
-            "source": SOURCE_REAUTH,
-            "entry_id": config_entry.entry_id,
-            "unique_id": config_entry.unique_id,
-        },
-        data=config,
-    )
     assert result["step_id"] == "reauth_confirm"
 
     # Test errors that can arise when getting a Notion API client:

tests/components/nuki/test_config_flow.py

@@ -210,9 +210,7 @@ async def test_reauth_success(hass: HomeAssistant) -> None:
     """Test starting a reauthentication flow."""
     entry = await setup_nuki_integration(hass)
 
-    result = await hass.config_entries.flow.async_init(
+    result = await entry.start_reauth_flow(hass)
-        DOMAIN, context={"source": config_entries.SOURCE_REAUTH}, data=entry.data
-    )
     assert result["type"] is FlowResultType.FORM
     assert result["step_id"] == "reauth_confirm"
 
@@ -241,9 +239,7 @@ async def test_reauth_invalid_auth(hass: HomeAssistant) -> None:
     """Test starting a reauthentication flow with invalid auth."""
     entry = await setup_nuki_integration(hass)
 
-    result = await hass.config_entries.flow.async_init(
+    result = await entry.start_reauth_flow(hass)
-        DOMAIN, context={"source": config_entries.SOURCE_REAUTH}, data=entry.data
-    )
     assert result["type"] is FlowResultType.FORM
     assert result["step_id"] == "reauth_confirm"
 
@@ -265,9 +261,7 @@ async def test_reauth_cannot_connect(hass: HomeAssistant) -> None:
     """Test starting a reauthentication flow with cannot connect."""
     entry = await setup_nuki_integration(hass)
 
-    result = await hass.config_entries.flow.async_init(
+    result = await entry.start_reauth_flow(hass)
-        DOMAIN, context={"source": config_entries.SOURCE_REAUTH}, data=entry.data
-    )
     assert result["type"] is FlowResultType.FORM
     assert result["step_id"] == "reauth_confirm"
 
@@ -289,9 +283,7 @@ async def test_reauth_unknown_exception(hass: HomeAssistant) -> None:
     """Test starting a reauthentication flow with an unknown exception."""
     entry = await setup_nuki_integration(hass)
 
-    result = await hass.config_entries.flow.async_init(
+    result = await entry.start_reauth_flow(hass)
-        DOMAIN, context={"source": config_entries.SOURCE_REAUTH}, data=entry.data
-    )
     assert result["type"] is FlowResultType.FORM
     assert result["step_id"] == "reauth_confirm"
 

tests/components/octoprint/test_config_flow.py

@@ -580,15 +580,7 @@ async def test_reauth_form(hass: HomeAssistant) -> None:
         unique_id="1234",
     )
     entry.add_to_hass(hass)
-    result = await hass.config_entries.flow.async_init(
+    result = await entry.start_reauth_flow(hass)
-        DOMAIN,
-        context={
-            "entry_id": entry.entry_id,
-            "source": config_entries.SOURCE_REAUTH,
-            "unique_id": entry.unique_id,
-        },
-        data=entry.data,
-    )
     assert result["type"] is FlowResultType.FORM
     assert not result["errors"]
 

tests/components/onvif/test_config_flow.py

@@ -769,11 +769,7 @@ async def test_form_reauth(hass: HomeAssistant) -> None:
     """Test reauthenticate."""
     entry, _, _ = await setup_onvif_integration(hass)
 
-    result = await hass.config_entries.flow.async_init(
+    result = await entry.start_reauth_flow(hass)
-        DOMAIN,
-        context={"source": config_entries.SOURCE_REAUTH, "entry_id": entry.entry_id},
-        data=entry.data,
-    )
     assert result["type"] is FlowResultType.FORM
     assert result["step_id"] == "reauth_confirm"
     assert (

tests/components/openexchangerates/test_config_flow.py

@@ -200,16 +200,7 @@ async def test_reauth(
 ) -> None:
     """Test we can reauthenticate the config entry."""
     mock_config_entry.add_to_hass(hass)
-    flow_context = {
+    result = await mock_config_entry.start_reauth_flow(hass)
-        "source": config_entries.SOURCE_REAUTH,
-        "entry_id": mock_config_entry.entry_id,
-        "title_placeholders": {"name": mock_config_entry.title},
-        "unique_id": mock_config_entry.unique_id,
-    }
-
-    result = await hass.config_entries.flow.async_init(
-        DOMAIN, context=flow_context, data=mock_config_entry.data
-    )
     assert result["type"] is FlowResultType.FORM
     assert result["errors"] is None
 

tests/components/openuv/test_config_flow.py

@@ -7,7 +7,7 @@ import pytest
 import voluptuous as vol
 
 from homeassistant.components.openuv import CONF_FROM_WINDOW, CONF_TO_WINDOW, DOMAIN
-from homeassistant.config_entries import SOURCE_REAUTH, SOURCE_USER
+from homeassistant.config_entries import SOURCE_USER
 from homeassistant.const import (
     CONF_API_KEY,
     CONF_ELEVATION,
@@ -19,6 +19,8 @@ from homeassistant.data_entry_flow import FlowResultType
 
 from .conftest import TEST_API_KEY, TEST_ELEVATION, TEST_LATITUDE, TEST_LONGITUDE
 
+from tests.common import MockConfigEntry
+
 pytestmark = pytest.mark.usefixtures("mock_setup_entry")
 
 
@@ -105,12 +107,10 @@ async def test_options_flow(
 
 
 async def test_step_reauth(
-    hass: HomeAssistant, config, config_entry, setup_config_entry
+    hass: HomeAssistant, config, config_entry: MockConfigEntry, setup_config_entry
 ) -> None:
     """Test that the reauth step works."""
-    result = await hass.config_entries.flow.async_init(
+    result = await config_entry.start_reauth_flow(hass)
-        DOMAIN, context={"source": SOURCE_REAUTH}, data=config
-    )
     assert result["step_id"] == "reauth_confirm"
 
     result = await hass.config_entries.flow.async_configure(result["flow_id"])

tests/components/osoenergy/test_config_flow.py

@@ -65,15 +65,7 @@ async def test_reauth_flow(hass: HomeAssistant) -> None:
         "homeassistant.components.osoenergy.config_flow.OSOEnergy.get_user_email",
         return_value=None,
     ):
-        result = await hass.config_entries.flow.async_init(
+        result = await mock_config.start_reauth_flow(hass)
-            DOMAIN,
-            context={
-                "source": config_entries.SOURCE_REAUTH,
-                "unique_id": mock_config.unique_id,
-                "entry_id": mock_config.entry_id,
-            },
-            data=mock_config.data,
-        )
 
     assert result["type"] is FlowResultType.FORM
     assert result["errors"] == {"base": "invalid_auth"}

tests/components/overkiz/test_config_flow.py

@@ -573,15 +573,7 @@ async def test_cloud_reauth_success(hass: HomeAssistant) -> None:
     )
     mock_entry.add_to_hass(hass)
 
-    result = await hass.config_entries.flow.async_init(
+    result = await mock_entry.start_reauth_flow(hass)
-        DOMAIN,
-        context={
-            "source": config_entries.SOURCE_REAUTH,
-            "unique_id": mock_entry.unique_id,
-            "entry_id": mock_entry.entry_id,
-        },
-        data=mock_entry.data,
-    )
 
     assert result["type"] is FlowResultType.FORM
     assert result["step_id"] == "cloud"
@@ -623,15 +615,7 @@ async def test_cloud_reauth_wrong_account(hass: HomeAssistant) -> None:
     )
     mock_entry.add_to_hass(hass)
 
-    result = await hass.config_entries.flow.async_init(
+    result = await mock_entry.start_reauth_flow(hass)
-        DOMAIN,
-        context={
-            "source": config_entries.SOURCE_REAUTH,
-            "unique_id": mock_entry.unique_id,
-            "entry_id": mock_entry.entry_id,
-        },
-        data=mock_entry.data,
-    )
 
     assert result["type"] is FlowResultType.FORM
     assert result["step_id"] == "cloud"
@@ -672,15 +656,7 @@ async def test_local_reauth_success(hass: HomeAssistant) -> None:
     )
     mock_entry.add_to_hass(hass)
 
-    result = await hass.config_entries.flow.async_init(
+    result = await mock_entry.start_reauth_flow(hass)
-        DOMAIN,
-        context={
-            "source": config_entries.SOURCE_REAUTH,
-            "unique_id": mock_entry.unique_id,
-            "entry_id": mock_entry.entry_id,
-        },
-        data=mock_entry.data,
-    )
 
     assert result["type"] is FlowResultType.FORM
     assert result["step_id"] == "local_or_cloud"
@@ -731,15 +707,7 @@ async def test_local_reauth_wrong_account(hass: HomeAssistant) -> None:
     )
     mock_entry.add_to_hass(hass)
 
-    result = await hass.config_entries.flow.async_init(
+    result = await mock_entry.start_reauth_flow(hass)
-        DOMAIN,
-        context={
-            "source": config_entries.SOURCE_REAUTH,
-            "unique_id": mock_entry.unique_id,
-            "entry_id": mock_entry.entry_id,
-        },
-        data=mock_entry.data,
-    )
     assert result["type"] is FlowResultType.FORM
     assert result["step_id"] == "local_or_cloud"
 

tests/components/ovo_energy/test_config_flow.py

@@ -121,15 +121,15 @@ async def test_full_flow_implementation(hass: HomeAssistant) -> None:
 
 async def test_reauth_authorization_error(hass: HomeAssistant) -> None:
     """Test we show user form on authorization error."""
+    mock_config = MockConfigEntry(
+        domain=DOMAIN, unique_id=UNIQUE_ID, data=FIXTURE_USER_INPUT
+    )
+    mock_config.add_to_hass(hass)
     with patch(
         "homeassistant.components.ovo_energy.config_flow.OVOEnergy.authenticate",
         return_value=False,
     ):
-        result = await hass.config_entries.flow.async_init(
+        result = await mock_config.start_reauth_flow(hass)
-            DOMAIN,
-            context={"source": config_entries.SOURCE_REAUTH},
-            data=FIXTURE_USER_INPUT,
-        )
 
         assert result["type"] is FlowResultType.FORM
         assert result["step_id"] == "reauth"
@@ -147,15 +147,15 @@ async def test_reauth_authorization_error(hass: HomeAssistant) -> None:
 
 async def test_reauth_connection_error(hass: HomeAssistant) -> None:
     """Test we show user form on connection error."""
+    mock_config = MockConfigEntry(
+        domain=DOMAIN, unique_id=UNIQUE_ID, data=FIXTURE_USER_INPUT
+    )
+    mock_config.add_to_hass(hass)
     with patch(
         "homeassistant.components.ovo_energy.config_flow.OVOEnergy.authenticate",
         side_effect=aiohttp.ClientError,
     ):
-        result = await hass.config_entries.flow.async_init(
+        result = await mock_config.start_reauth_flow(hass)
-            DOMAIN,
-            context={"source": config_entries.SOURCE_REAUTH},
-            data=FIXTURE_USER_INPUT,
-        )
 
         assert result["type"] is FlowResultType.FORM
         assert result["step_id"] == "reauth"
@@ -173,20 +173,15 @@ async def test_reauth_connection_error(hass: HomeAssistant) -> None:
 
 async def test_reauth_flow(hass: HomeAssistant) -> None:
     """Test reauth works."""
-    with patch(
-        "homeassistant.components.ovo_energy.config_flow.OVOEnergy.authenticate",
-        return_value=False,
-    ):
     mock_config = MockConfigEntry(
         domain=DOMAIN, unique_id=UNIQUE_ID, data=FIXTURE_USER_INPUT
     )
     mock_config.add_to_hass(hass)
-
+    with patch(
-        result = await hass.config_entries.flow.async_init(
+        "homeassistant.components.ovo_energy.config_flow.OVOEnergy.authenticate",
-            DOMAIN,
+        return_value=False,
-            context={"source": config_entries.SOURCE_REAUTH},
+    ):
-            data=FIXTURE_USER_INPUT,
+        result = await mock_config.start_reauth_flow(hass)
-        )
 
         assert result["type"] is FlowResultType.FORM
         assert result["step_id"] == "reauth"