text: """Define tests for the SimpliSafe config flow."""
  from unittest.mock import AsyncMock, Mock, patch
  
  import pytest
  from simplipy.errors import InvalidCredentialsError, SimplipyError
  
  from homeassistant import data_entry_flow
  from homeassistant.components.simplisafe import DOMAIN
  from homeassistant.components.simplisafe.config_flow import CONF_AUTH_CODE
  from homeassistant.components.simplisafe.const import CONF_USER_ID
  from homeassistant.config_entries import SOURCE_REAUTH, SOURCE_USER
  from homeassistant.const import CONF_CODE, CONF_PASSWORD, CONF_TOKEN, CONF_USERNAME
  
  from tests.common import MockConfigEntry
  
  
  @pytest.fixture(name="api")
  def api_fixture():
      """Define a fixture for simplisafe-python API object."""
      api = Mock()
      api.refresh_token = "token123"
      api.user_id = "12345"
      return api
  
  
  @pytest.fixture(name="mock_async_from_auth")
  def mock_async_from_auth_fixture(api):
      """Define a fixture for simplipy.API.async_from_auth."""
      with patch(
          "homeassistant.components.simplisafe.config_flow.API.async_from_auth",
      ) as mock_async_from_auth:
          mock_async_from_auth.side_effect = AsyncMock(return_value=api)
          yield mock_async_from_auth
  
  
  async def test_duplicate_error(hass, mock_async_from_auth):
      """Test that errors are shown when duplicates are added."""
      MockConfigEntry(
          domain=DOMAIN,
          unique_id="12345",
          data={
              CONF_USER_ID: "12345",
              CONF_TOKEN: "token123",
          },
      ).add_to_hass(hass)
  
      with patch(
          "homeassistant.components.simplisafe.async_setup_entry", return_value=True
      ):
          result = await hass.config_entries.flow.async_init(
              DOMAIN, context={"source": SOURCE_USER}
          )
          assert result["step_id"] == "user"
          assert result["type"] == data_entry_flow.RESULT_TYPE_FORM
  
          result = await hass.config_entries.flow.async_configure(
              result["flow_id"], user_input={}
          )
          result = await hass.config_entries.flow.async_configure(
              result["flow_id"], user_input={CONF_AUTH_CODE: "code123"}
          )
          assert result["type"] == data_entry_flow.RESULT_TYPE_ABORT
          assert result["reason"] == "already_configured"
  
  
  async def test_invalid_credentials(hass, mock_async_from_auth):
      """Test that invalid credentials show the correct error."""
      mock_async_from_auth.side_effect = AsyncMock(side_effect=InvalidCredentialsError)
  
      result = await hass.config_entries.flow.async_init(
          DOMAIN, context={"source": SOURCE_USER}
      )
      assert result["step_id"] == "user"
      assert result["type"] == data_entry_flow.RESULT_TYPE_FORM
  
      result = await hass.config_entries.flow.async_configure(
          result["flow_id"], user_input={}
      )
      result = await hass.config_entries.flow.async_configure(
          result["flow_id"], user_input={CONF_AUTH_CODE: "code123"}
      )
      assert result["type"] == data_entry_flow.RESULT_TYPE_FORM
      assert result["errors"] == {"base": "invalid_auth"}
  
  
  async def test_options_flow(hass):
      """Test config flow options."""
      entry = MockConfigEntry(
          domain=DOMAIN,
          unique_id="abcde12345",
          data={CONF_USER_ID: "12345", CONF_TOKEN: "token456"},
          options={CONF_CODE: "1234"},
      )
      entry.add_to_hass(hass)
  
      with patch(
          "homeassistant.components.simplisafe.async_setup_entry", return_value=True
      ):
          await hass.config_entries.async_setup(entry.entry_id)
          result = await hass.config_entries.options.async_init(entry.entry_id)
  
          assert result["type"] == data_entry_flow.RESULT_TYPE_FORM
          assert result["step_id"] == "init"
  
          result = await hass.config_entries.options.async_configure(
              result["flow_id"], user_input={CONF_CODE: "4321"}
          )
  
          assert result["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY
          assert entry.options == {CONF_CODE: "4321"}
  
  
  async def test_step_reauth_old_format(hass, mock_async_from_auth):
      """Test the re-auth step with "old" config entries (those with user IDs)."""
      MockConfigEntry(
          domain=DOMAIN,
          unique_id="user@email.com",
          data={
              CONF_USERNAME: "user@email.com",
              CONF_PASSWORD: "password",
          },
      ).add_to_hass(hass)
  
      result = await hass.config_entries.flow.async_init(
          DOMAIN,
          context={"source": SOURCE_REAUTH},
          data={CONF_USERNAME: "user@email.com", CONF_PASSWORD: "password"},
      )
      assert result["step_id"] == "user"
  
      with patch(
          "homeassistant.components.simplisafe.async_setup_entry", return_value=True
      ), patch("homeassistant.config_entries.ConfigEntries.async_reload"):
          result = await hass.config_entries.flow.async_configure(
              result["flow_id"], user_input={}
          )
          result = await hass.config_entries.flow.async_configure(
              result["flow_id"], user_input={CONF_AUTH_CODE: "code123"}
          )
          assert result["type"] == data_entry_flow.RESULT_TYPE_ABORT
          assert result["reason"] == "reauth_successful"
  
      assert len(hass.config_entries.async_entries()) == 1
      [config_entry] = hass.config_entries.async_entries(DOMAIN)
      assert config_entry.data == {CONF_USER_ID: "12345", CONF_TOKEN: "token123"}
  
  
  async def test_step_reauth_new_format(hass, mock_async_from_auth):
      """Test the re-auth step with "new" config entries (those with user IDs)."""
      MockConfigEntry(
          domain=DOMAIN,
          unique_id="12345",
          data={
              CONF_USER_ID: "12345",
              CONF_TOKEN: "token123",
          },
      ).add_to_hass(hass)
  
      result = await hass.config_entries.flow.async_init(
          DOMAIN,
          context={"source": SOURCE_REAUTH},
          data={CONF_USER_ID: "12345", CONF_TOKEN: "token123"},
      )
      assert result["step_id"] == "user"
  
      with patch(
          "homeassistant.components.simplisafe.async_setup_entry", return_value=True
      ), patch("homeassistant.config_entries.ConfigEntries.async_reload"):
          result = await hass.config_entries.flow.async_configure(
              result["flow_id"], user_input={}
          )
          result = await hass.config_entries.flow.async_configure(
              result["flow_id"], user_input={CONF_AUTH_CODE: "code123"}
          )
          assert result["type"] == data_entry_flow.RESULT_TYPE_ABORT
          assert result["reason"] == "reauth_successful"
  
      assert len(hass.config_entries.async_entries()) == 1
      [config_entry] = hass.config_entries.async_entries(DOMAIN)
      assert config_entry.data == {CONF_USER_ID: "12345", CONF_TOKEN: "token123"}
  
  
  async def test_step_reauth_wrong_account(hass, api, mock_async_from_auth):
      """Test the re-auth step returning a different account from this one."""
      MockConfigEntry(
          domain=DOMAIN,
          unique_id="12345",
          data={
              CONF_USER_ID: "12345",
              CONF_TOKEN: "token123",
          },
      ).add_to_hass(hass)
  
      result = await hass.config_entries.flow.async_init(
          DOMAIN,
          context={"source": SOURCE_REAUTH},
          data={CONF_USER_ID: "12345", CONF_TOKEN: "token123"},
      )
      assert result["step_id"] == "user"
  
      # Simulate the next auth call returning a different user ID than the one we've
      # identified as this entry's unique ID:
      api.user_id = "67890"
  
      with patch(
          "homeassistant.components.simplisafe.async_setup_entry", return_value=True
      ), patch("homeassistant.config_entries.ConfigEntries.async_reload"):
          result = await hass.config_entries.flow.async_configure(
              result["flow_id"], user_input={}
          )
          result = await hass.config_entries.flow.async_configure(
              result["flow_id"], user_input={CONF_AUTH_CODE: "code123"}
          )
          assert result["type"] == data_entry_flow.RESULT_TYPE_ABORT
          assert result["reason"] == "wrong_account"
  
      assert len(hass.config_entries.async_entries()) == 1
      [config_entry] = hass.config_entries.async_entries(DOMAIN)
      assert config_entry.unique_id == "12345"
  
  
  async def test_step_user(hass, mock_async_from_auth):
      """Test the user step."""
      result = await hass.config_entries.flow.async_init(
          DOMAIN, context={"source": SOURCE_USER}
      )
      assert result["step_id"] == "user"
  
      with patch(
          "homeassistant.components.simplisafe.async_setup_entry", return_value=True
      ), patch("homeassistant.config_entries.ConfigEntries.async_reload"):
          result = await hass.config_entries.flow.async_configure(
              result["flow_id"], user_input={}
          )
          result = await hass.config_entries.flow.async_configure(
              result["flow_id"], user_input={CONF_AUTH_CODE: "code123"}
          )
          assert result["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY
  
      assert len(hass.config_entries.async_entries()) == 1
      [config_entry] = hass.config_entries.async_entries(DOMAIN)
      assert config_entry.data == {CONF_USER_ID: "12345", CONF_TOKEN: "token123"}
  
  
  async def test_unknown_error(hass, mock_async_from_auth):
      """Test that an unknown error shows ohe correct error."""
      mock_async_from_auth.side_effect = AsyncMock(side_effect=SimplipyError)
  
      result = await hass.config_entries.flow.async_init(
          DOMAIN, context={"source": SOURCE_USER}
      )
      assert result["step_id"] == "user"
      assert result["type"] == data_entry_flow.RESULT_TYPE_FORM
  
      result = await hass.config_entries.flow.async_configure(
          result["flow_id"], user_input={}
      )
      result = await hass.config_entries.flow.async_configure(
          result["flow_id"], user_input={CONF_AUTH_CODE: "code123"}
      )
      assert result["type"] == data_entry_flow.RESULT_TYPE_FORM
      assert result["errors"] == {"base": "unknown"}
  