diff --git a/tests/components/abode/test_config_flow.py b/tests/components/abode/test_config_flow.py
index a37fb8cbe33..2abed387566 100644
--- a/tests/components/abode/test_config_flow.py
+++ b/tests/components/abode/test_config_flow.py
@@ -10,7 +10,6 @@ from jaraco.abode.helpers.errors import MFA_CODE_REQUIRED
 import pytest
 from requests.exceptions import ConnectTimeout
 
-from homeassistant.components.abode import config_flow
 from homeassistant.components.abode.const import CONF_POLLING, DOMAIN
 from homeassistant.config_entries import SOURCE_USER
 from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
@@ -22,114 +21,110 @@ from tests.common import MockConfigEntry
 pytestmark = pytest.mark.usefixtures("mock_setup_entry")
 
 
-async def test_show_form(hass: HomeAssistant) -> None:
-    """Test that the form is served with no input."""
-    flow = config_flow.AbodeFlowHandler()
-    flow.hass = hass
-
-    result = await flow.async_step_user(user_input=None)
-
-    assert result["type"] is FlowResultType.FORM
-    assert result["step_id"] == "user"
-
-
 async def test_one_config_allowed(hass: HomeAssistant) -> None:
     """Test that only one Abode configuration is allowed."""
-    flow = config_flow.AbodeFlowHandler()
-    flow.hass = hass
-
     MockConfigEntry(
         domain=DOMAIN,
         data={CONF_USERNAME: "user@email.com", CONF_PASSWORD: "password"},
     ).add_to_hass(hass)
 
-    step_user_result = await flow.async_step_user()
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN, context={"source": SOURCE_USER}
+    )
 
-    assert step_user_result["type"] is FlowResultType.ABORT
-    assert step_user_result["reason"] == "single_instance_allowed"
+    assert result["type"] is FlowResultType.ABORT
+    assert result["reason"] == "single_instance_allowed"
 
 
-async def test_invalid_credentials(hass: HomeAssistant) -> None:
-    """Test that invalid credentials throws an error."""
-    conf = {CONF_USERNAME: "user@email.com", CONF_PASSWORD: "password"}
-
-    flow = config_flow.AbodeFlowHandler()
-    flow.hass = hass
+async def test_user_flow(hass: HomeAssistant) -> None:
+    """Test user flow, with various errors."""
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN, context={"source": SOURCE_USER}
+    )
+    assert result["type"] is FlowResultType.FORM
+    assert result["step_id"] == "user"
 
+    # Test that invalid credentials throws an error.
     with patch(
         "homeassistant.components.abode.config_flow.Abode",
         side_effect=AbodeAuthenticationException(
             (HTTPStatus.BAD_REQUEST, "auth error")
         ),
     ):
-        result = await flow.async_step_user(user_input=conf)
-        assert result["errors"] == {"base": "invalid_auth"}
-
-
-async def test_connection_auth_error(hass: HomeAssistant) -> None:
-    """Test other than invalid credentials throws an error."""
-    conf = {CONF_USERNAME: "user@email.com", CONF_PASSWORD: "password"}
-
-    flow = config_flow.AbodeFlowHandler()
-    flow.hass = hass
+        result = await hass.config_entries.flow.async_configure(
+            result["flow_id"],
+            user_input={CONF_USERNAME: "user@email.com", CONF_PASSWORD: "password"},
+        )
+    assert result["type"] is FlowResultType.FORM
+    assert result["step_id"] == "user"
+    assert result["errors"] == {"base": "invalid_auth"}
 
+    # Test other than invalid credentials throws an error.
     with patch(
         "homeassistant.components.abode.config_flow.Abode",
         side_effect=AbodeAuthenticationException(
             (HTTPStatus.INTERNAL_SERVER_ERROR, "connection error")
         ),
     ):
-        result = await flow.async_step_user(user_input=conf)
-        assert result["errors"] == {"base": "cannot_connect"}
-
-
-async def test_connection_error(hass: HomeAssistant) -> None:
-    """Test login throws an error if connection times out."""
-    conf = {CONF_USERNAME: "user@email.com", CONF_PASSWORD: "password"}
-
-    flow = config_flow.AbodeFlowHandler()
-    flow.hass = hass
+        result = await hass.config_entries.flow.async_configure(
+            result["flow_id"],
+            user_input={CONF_USERNAME: "user@email.com", CONF_PASSWORD: "password"},
+        )
+    assert result["type"] is FlowResultType.FORM
+    assert result["step_id"] == "user"
+    assert result["errors"] == {"base": "cannot_connect"}
 
+    # Test login throws an error if connection times out.
     with patch(
         "homeassistant.components.abode.config_flow.Abode",
         side_effect=ConnectTimeout,
     ):
-        result = await flow.async_step_user(user_input=conf)
-        assert result["errors"] == {"base": "cannot_connect"}
+        result = await hass.config_entries.flow.async_configure(
+            result["flow_id"],
+            user_input={CONF_USERNAME: "user@email.com", CONF_PASSWORD: "password"},
+        )
+    assert result["type"] is FlowResultType.FORM
+    assert result["step_id"] == "user"
+    assert result["errors"] == {"base": "cannot_connect"}
 
-
-async def test_step_user(hass: HomeAssistant) -> None:
-    """Test that the user step works."""
-    conf = {CONF_USERNAME: "user@email.com", CONF_PASSWORD: "password"}
+    # Test success
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN, context={"source": SOURCE_USER}
+    )
 
     with patch("homeassistant.components.abode.config_flow.Abode"):
-        result = await hass.config_entries.flow.async_init(
-            DOMAIN, context={"source": SOURCE_USER}, data=conf
+        result = await hass.config_entries.flow.async_configure(
+            result["flow_id"],
+            user_input={CONF_USERNAME: "user@email.com", CONF_PASSWORD: "password"},
         )
 
-        assert result["type"] is FlowResultType.CREATE_ENTRY
-        assert result["title"] == "user@email.com"
-        assert result["data"] == {
-            CONF_USERNAME: "user@email.com",
-            CONF_PASSWORD: "password",
-            CONF_POLLING: False,
-        }
+    assert result["type"] is FlowResultType.CREATE_ENTRY
+    assert result["title"] == "user@email.com"
+    assert result["data"] == {
+        CONF_USERNAME: "user@email.com",
+        CONF_PASSWORD: "password",
+        CONF_POLLING: False,
+    }
 
 
 async def test_step_mfa(hass: HomeAssistant) -> None:
     """Test that the MFA step works."""
-    conf = {CONF_USERNAME: "user@email.com", CONF_PASSWORD: "password"}
+
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN, context={"source": SOURCE_USER}
+    )
 
     with patch(
         "homeassistant.components.abode.config_flow.Abode",
         side_effect=AbodeAuthenticationException(MFA_CODE_REQUIRED),
     ):
-        result = await hass.config_entries.flow.async_init(
-            DOMAIN, context={"source": SOURCE_USER}, data=conf
+        result = await hass.config_entries.flow.async_configure(
+            result["flow_id"],
+            user_input={CONF_USERNAME: "user@email.com", CONF_PASSWORD: "password"},
         )
 
-        assert result["type"] is FlowResultType.FORM
-        assert result["step_id"] == "mfa"
+    assert result["type"] is FlowResultType.FORM
+    assert result["step_id"] == "mfa"
 
     with patch(
         "homeassistant.components.abode.config_flow.Abode",
@@ -141,46 +136,51 @@ async def test_step_mfa(hass: HomeAssistant) -> None:
             result["flow_id"], user_input={"mfa_code": "123456"}
         )
 
-        assert result["errors"] == {"base": "invalid_mfa_code"}
+    assert result["type"] is FlowResultType.FORM
+    assert result["step_id"] == "mfa"
+    assert result["errors"] == {"base": "invalid_mfa_code"}
 
     with patch("homeassistant.components.abode.config_flow.Abode"):
         result = await hass.config_entries.flow.async_configure(
             result["flow_id"], user_input={"mfa_code": "123456"}
         )
 
-        assert result["type"] is FlowResultType.CREATE_ENTRY
-        assert result["title"] == "user@email.com"
-        assert result["data"] == {
-            CONF_USERNAME: "user@email.com",
-            CONF_PASSWORD: "password",
-            CONF_POLLING: False,
-        }
+    assert result["type"] is FlowResultType.CREATE_ENTRY
+    assert result["title"] == "user@email.com"
+    assert result["data"] == {
+        CONF_USERNAME: "user@email.com",
+        CONF_PASSWORD: "password",
+        CONF_POLLING: False,
+    }
 
 
 async def test_step_reauth(hass: HomeAssistant) -> None:
     """Test the reauth flow."""
-    conf = {CONF_USERNAME: "user@email.com", CONF_PASSWORD: "password"}
-
     entry = MockConfigEntry(
         domain=DOMAIN,
         unique_id="user@email.com",
-        data=conf,
+        data={CONF_USERNAME: "user@email.com", CONF_PASSWORD: "password"},
     )
     entry.add_to_hass(hass)
 
-    with patch("homeassistant.components.abode.config_flow.Abode"):
-        result = await entry.start_reauth_flow(hass)
+    result = await entry.start_reauth_flow(hass)
 
-        assert result["type"] is FlowResultType.FORM
-        assert result["step_id"] == "reauth_confirm"
+    assert result["type"] is FlowResultType.FORM
+    assert result["step_id"] == "reauth_confirm"
 
-        with patch("homeassistant.config_entries.ConfigEntries.async_reload"):
-            result = await hass.config_entries.flow.async_configure(
-                result["flow_id"],
-                user_input=conf,
-            )
+    with (
+        patch("homeassistant.components.abode.config_flow.Abode"),
+    ):
+        result = await hass.config_entries.flow.async_configure(
+            result["flow_id"],
+            user_input={
+                CONF_USERNAME: "user@email.com",
+                CONF_PASSWORD: "new_password",
+            },
+        )
 
-            assert result["type"] is FlowResultType.ABORT
-            assert result["reason"] == "reauth_successful"
+    assert result["type"] is FlowResultType.ABORT
+    assert result["reason"] == "reauth_successful"
 
-        assert len(hass.config_entries.async_entries()) == 1
+    assert len(hass.config_entries.async_entries()) == 1
+    assert entry.data[CONF_PASSWORD] == "new_password"