How to use the regenmaschine.errors.RainMachineError function in regenmaschine

async def test_invalid_password(hass):
    """Test that an invalid password throws an error."""
    conf = {
        CONF_IP_ADDRESS: "192.168.1.100",
        CONF_PASSWORD: "bad_password",
        CONF_PORT: 8080,
        CONF_SSL: True,
    }

    flow = config_flow.RainMachineFlowHandler()
    flow.hass = hass

    with patch(
        "homeassistant.components.rainmachine.config_flow.login",
        return_value=mock_coro(exception=RainMachineError),
    ):
        result = await flow.async_step_user(user_input=conf)
        assert result["errors"] == {CONF_PASSWORD: "invalid_credentials"}

websession,
            port=config_entry.data[CONF_PORT],
            ssl=config_entry.data[CONF_SSL],
        )
        rainmachine = RainMachine(
            client,
            config_entry.data.get(CONF_BINARY_SENSORS, {}).get(
                CONF_MONITORED_CONDITIONS, list(BINARY_SENSORS)
            ),
            config_entry.data.get(CONF_SENSORS, {}).get(
                CONF_MONITORED_CONDITIONS, list(SENSORS)
            ),
            config_entry.data.get(CONF_ZONE_RUN_TIME, DEFAULT_ZONE_RUN),
        )
        await rainmachine.async_update()
    except RainMachineError as err:
        _LOGGER.error("An error occurred: %s", err)
        raise ConfigEntryNotReady

    hass.data[DOMAIN][DATA_CLIENT][config_entry.entry_id] = rainmachine

    for component in ("binary_sensor", "sensor", "switch"):
        hass.async_create_task(
            hass.config_entries.async_forward_entry_setup(config_entry, component)
        )

    async def refresh(event_time):
        """Refresh RainMachine sensor data."""
        _LOGGER.debug("Updating RainMachine sensor data")
        await rainmachine.async_update()
        async_dispatcher_send(hass, SENSOR_UPDATE_TOPIC)

)
        ):
            tasks[RESTRICTIONS_CURRENT] = self.client.restrictions.current()

        if (
            any(
                c in self.binary_sensor_conditions
                for c in (TYPE_FREEZE_PROTECTION, TYPE_HOT_DAYS)
            )
            or TYPE_FREEZE_TEMP in self.sensor_conditions
        ):
            tasks[RESTRICTIONS_UNIVERSAL] = self.client.restrictions.universal()

        results = await asyncio.gather(*tasks.values(), return_exceptions=True)
        for operation, result in zip(tasks, results):
            if isinstance(result, RainMachineError):
                _LOGGER.error(
                    "There was an error while updating %s: %s", operation, result
                )
                continue

            self.data[operation] = result

return await self._show_form()

        if user_input[CONF_IP_ADDRESS] in configured_instances(self.hass):
            return await self._show_form({CONF_IP_ADDRESS: "identifier_exists"})

        websession = aiohttp_client.async_get_clientsession(self.hass)

        try:
            await login(
                user_input[CONF_IP_ADDRESS],
                user_input[CONF_PASSWORD],
                websession,
                port=user_input.get(CONF_PORT, DEFAULT_PORT),
                ssl=True,
            )
        except RainMachineError:
            return await self._show_form({CONF_PASSWORD: "invalid_credentials"})

        # Since the config entry doesn't allow for configuration of SSL, make
        # sure it's set:
        if user_input.get(CONF_SSL) is None:
            user_input[CONF_SSL] = DEFAULT_SSL

        # Timedeltas are easily serializable, so store the seconds instead:
        scan_interval = user_input.get(CONF_SCAN_INTERVAL, DEFAULT_SCAN_INTERVAL)
        user_input[CONF_SCAN_INTERVAL] = scan_interval.seconds

        # Unfortunately, RainMachine doesn't provide a way to refresh the
        # access token without using the IP address and password, so we have to
        # store it:
        return self.async_create_entry(
            title=user_input[CONF_IP_ADDRESS], data=user_input

Note that this call does not take into account interested entities when making
        the API calls; we make the reasonable assumption that switches will always be
        enabled.
        """
        _LOGGER.debug("Updating program and zone data for RainMachine")

        tasks = {
            DATA_PROGRAMS: self.async_fetch_from_api(DATA_PROGRAMS),
            DATA_ZONES: self.async_fetch_from_api(DATA_ZONES),
            DATA_ZONES_DETAILS: self.async_fetch_from_api(DATA_ZONES_DETAILS),
        }

        results = await asyncio.gather(*tasks.values(), return_exceptions=True)
        for api_category, result in zip(tasks, results):
            if isinstance(result, RainMachineError):
                _LOGGER.error(
                    "There was an error while updating %s: %s", api_category, result
                )

        async_dispatcher_send(self.hass, PROGRAM_UPDATE_TOPIC)
        async_dispatcher_send(self.hass, ZONE_UPDATE_TOPIC)

async def async_setup_entry(hass, config_entry):
    """Set up RainMachine as config entry."""
    _verify_domain_control = verify_domain_control(hass, DOMAIN)

    websession = aiohttp_client.async_get_clientsession(hass)
    client = Client(websession)

    try:
        await client.load_local(
            config_entry.data[CONF_IP_ADDRESS],
            config_entry.data[CONF_PASSWORD],
            port=config_entry.data[CONF_PORT],
            ssl=config_entry.data[CONF_SSL],
        )
    except RainMachineError as err:
        _LOGGER.error("An error occurred: %s", err)
        raise ConfigEntryNotReady
    else:
        # regenmaschine can load multiple controllers at once, but we only grab the one
        # we loaded above:
        controller = next(iter(client.controllers.values()))

        rainmachine = RainMachine(
            hass,
            controller,
            config_entry.data.get(CONF_ZONE_RUN_TIME, DEFAULT_ZONE_RUN),
            config_entry.data[CONF_SCAN_INTERVAL],
        )

    # Update the data object, which at this point (prior to any sensors registering
    # "interest" in the API), will focus on grabbing the latest program and zone data: