async def test_switches_states(hass: HomeAssistant, aioclient_mock: AiohttpClientMocker): """Test we get sensor data.""" await async_setup_platform(hass, aioclient_mock, DOMAIN) assert hass.states.get( f"switch.{DEFAULT_NAME}_usb_port_status").state == STATE_OFF assert hass.states.get( f"switch.{DEFAULT_NAME}_ac_port_status").state == STATE_ON entity_id = f"switch.{DEFAULT_NAME}_12v_port_status" assert hass.states.get(entity_id).state == STATE_OFF aioclient_mock.post( "http://1.2.3.4/state", text=load_fixture("goalzero/state_change.json"), ) await hass.services.async_call( DOMAIN, SERVICE_TURN_ON, {ATTR_ENTITY_ID: [entity_id]}, blocking=True, ) assert hass.states.get(entity_id).state == STATE_ON aioclient_mock.clear_requests() aioclient_mock.post( "http://1.2.3.4/state", text=load_fixture("goalzero/state_data.json"), ) await hass.services.async_call( DOMAIN, SERVICE_TURN_OFF, {ATTR_ENTITY_ID: [entity_id]}, blocking=True, ) assert hass.states.get(entity_id).state == STATE_OFF
async def test_sensor_updates_with_empty_release_array( hass: HomeAssistant, init_integration: MockConfigEntry, aioclient_mock: AiohttpClientMocker, ) -> None: """Test the sensor updates by default GitHub sensors.""" state = hass.states.get(TEST_SENSOR_ENTITY) assert state.state == "v1.0.0" response_json = json.loads(load_fixture("graphql.json", DOMAIN)) response_json["data"]["repository"]["release"] = None headers = json.loads(load_fixture("base_headers.json", DOMAIN)) aioclient_mock.clear_requests() aioclient_mock.get( f"https://api.github.com/repos/{TEST_REPOSITORY}/events", json=[], headers=headers, ) aioclient_mock.post( "https://api.github.com/graphql", json=response_json, headers=headers, ) async_fire_time_changed(hass, dt.utcnow() + FALLBACK_UPDATE_INTERVAL) await hass.async_block_till_done() new_state = hass.states.get(TEST_SENSOR_ENTITY) assert new_state.state == "unavailable"
async def test_bad_alerts( hass: HomeAssistant, hass_ws_client, aioclient_mock: AiohttpClientMocker, ha_version, fixture, expected_alerts, ) -> None: """Test creating issues based on alerts.""" fixture_content = load_fixture(fixture, "homeassistant_alerts") aioclient_mock.clear_requests() aioclient_mock.get( "https://alerts.home-assistant.io/alerts.json", text=fixture_content, ) for alert in json.loads(fixture_content): stub_alert(aioclient_mock, alert["filename"]) activated_components = ( "darksky", "hikvision", "hikvisioncam", ) for domain in activated_components: hass.config.components.add(domain) with patch( "homeassistant.components.homeassistant_alerts.__version__", ha_version, ): assert await async_setup_component(hass, DOMAIN, {}) client = await hass_ws_client(hass) await client.send_json({"id": 1, "type": "repairs/list_issues"}) msg = await client.receive_json() assert msg["success"] assert msg["result"] == { "issues": [{ "breaks_in_ha_version": None, "created": ANY, "dismissed_version": None, "domain": "homeassistant_alerts", "ignored": False, "is_fixable": False, "issue_id": f"{alert}_{integration}", "issue_domain": integration, "learn_more_url": None, "severity": "warning", "translation_key": "alert", "translation_placeholders": { "title": f"Title for {alert}", "description": f"Content for {alert}", }, } for alert, integration in expected_alerts] }
async def test_scan_calendars( hass: HomeAssistant, component_setup: ComponentSetup, mock_calendars_list: ApiResult, mock_events_list: ApiResult, setup_config_entry: MockConfigEntry, aioclient_mock: AiohttpClientMocker, ) -> None: """Test finding a calendar from the API.""" mock_calendars_list({"items": []}) assert await component_setup() calendar_1 = { "id": "calendar-id-1", "summary": "Calendar 1", } calendar_2 = { "id": "calendar-id-2", "summary": "Calendar 2", } aioclient_mock.clear_requests() mock_calendars_list({"items": [calendar_1]}) mock_events_list({}, calendar_id="calendar-id-1") await hass.services.async_call(DOMAIN, SERVICE_SCAN_CALENDARS, {}, blocking=True) await hass.async_block_till_done() state = hass.states.get("calendar.calendar_1") assert state assert state.name == "Calendar 1" assert state.state == STATE_OFF assert not hass.states.get("calendar.calendar_2") aioclient_mock.clear_requests() mock_calendars_list({"items": [calendar_1, calendar_2]}) mock_events_list({}, calendar_id="calendar-id-1") mock_events_list({}, calendar_id="calendar-id-2") await hass.services.async_call(DOMAIN, SERVICE_SCAN_CALENDARS, {}, blocking=True) await hass.async_block_till_done() state = hass.states.get("calendar.calendar_1") assert state assert state.name == "Calendar 1" assert state.state == STATE_OFF state = hass.states.get("calendar.calendar_2") assert state assert state.name == "Calendar 2" assert state.state == STATE_OFF
def mock_responses( aioclient_mock: AiohttpClientMocker, host: str = MOCK_HOST, fixture_set: str = "symo", inverter_ids: list[str | int] = [1], night: bool = False, ) -> None: """Mock responses for Fronius devices.""" aioclient_mock.clear_requests() _night = "_night" if night else "" aioclient_mock.get( f"{host}/solar_api/GetAPIVersion.cgi", text=load_fixture(f"{fixture_set}/GetAPIVersion.json", "fronius"), ) for inverter_id in inverter_ids: aioclient_mock.get( f"{host}/solar_api/v1/GetInverterRealtimeData.cgi?Scope=Device&" f"DeviceId={inverter_id}&DataCollection=CommonInverterData", text=load_fixture( f"{fixture_set}/GetInverterRealtimeData_Device_{inverter_id}{_night}.json", "fronius", ), ) aioclient_mock.get( f"{host}/solar_api/v1/GetInverterInfo.cgi", text=load_fixture(f"{fixture_set}/GetInverterInfo.json", "fronius"), ) aioclient_mock.get( f"{host}/solar_api/v1/GetLoggerInfo.cgi", text=load_fixture(f"{fixture_set}/GetLoggerInfo.json", "fronius"), ) aioclient_mock.get( f"{host}/solar_api/v1/GetMeterRealtimeData.cgi?Scope=System", text=load_fixture(f"{fixture_set}/GetMeterRealtimeData.json", "fronius"), ) aioclient_mock.get( f"{host}/solar_api/v1/GetPowerFlowRealtimeData.fcgi", text=load_fixture( f"{fixture_set}/GetPowerFlowRealtimeData{_night}.json", "fronius"), ) aioclient_mock.get( f"{host}/solar_api/v1/GetStorageRealtimeData.cgi?Scope=System", text=load_fixture(f"{fixture_set}/GetStorageRealtimeData.json", "fronius"), ) aioclient_mock.get( f"{host}/solar_api/v1/GetOhmPilotRealtimeData.cgi?Scope=System", text=load_fixture(f"{fixture_set}/GetOhmPilotRealtimeData.json", "fronius"), )
async def test_multiple_config_entries( hass: HomeAssistant, component_setup: ComponentSetup, mock_calendars_list: ApiResult, test_api_calendar: dict[str, Any], mock_events_list: ApiResult, config_entry: MockConfigEntry, aioclient_mock: AiohttpClientMocker, ) -> None: """Test finding a calendar from the API.""" assert await component_setup() config_entry1 = MockConfigEntry( domain=DOMAIN, data=config_entry.data, unique_id=EMAIL_ADDRESS ) calendar1 = { **test_api_calendar, "id": "calendar-id1", "summary": "Example Calendar 1", } mock_calendars_list({"items": [calendar1]}) mock_events_list({}, calendar_id="calendar-id1") config_entry1.add_to_hass(hass) await hass.config_entries.async_setup(config_entry1.entry_id) await hass.async_block_till_done() state = hass.states.get("calendar.example_calendar_1") assert state assert state.state == STATE_OFF assert state.attributes.get(ATTR_FRIENDLY_NAME) == "Example calendar 1" config_entry2 = MockConfigEntry( domain=DOMAIN, data=config_entry.data, unique_id="*****@*****.**" ) calendar2 = { **test_api_calendar, "id": "calendar-id2", "summary": "Example Calendar 2", } aioclient_mock.clear_requests() mock_calendars_list({"items": [calendar2]}) mock_events_list({}, calendar_id="calendar-id2") config_entry2.add_to_hass(hass) await hass.config_entries.async_setup(config_entry2.entry_id) await hass.async_block_till_done() state = hass.states.get("calendar.example_calendar_2") assert state assert state.attributes.get(ATTR_FRIENDLY_NAME) == "Example calendar 2"
async def test_failed_update_and_reconnection( hass: HomeAssistant, aioclient_mock: AiohttpClientMocker): """Test failed update and reconnection.""" await setup_platform(hass, aioclient_mock, SENSOR_DOMAIN) assert hass.states.get("sensor.power_usage").state == "1580" aioclient_mock.clear_requests() await mock_responses(hass, aioclient_mock, error=True) next_update = dt_util.utcnow() + timedelta(seconds=30) async_fire_time_changed(hass, next_update) await hass.async_block_till_done() assert hass.states.get("sensor.power_usage").state == STATE_UNAVAILABLE aioclient_mock.clear_requests() await mock_responses(hass, aioclient_mock) next_update = dt_util.utcnow() + timedelta(seconds=30) async_fire_time_changed(hass, next_update) await hass.async_block_till_done() assert hass.states.get("sensor.power_usage").state == "1580"
async def test_add_event_date_time( hass: HomeAssistant, component_setup: ComponentSetup, mock_calendars_list: ApiResult, mock_insert_event: Callable[[str, dict[str, Any]], None], test_api_calendar: dict[str, Any], mock_events_list: ApiResult, setup_config_entry: MockConfigEntry, aioclient_mock: AiohttpClientMocker, add_event_call_service: Callable[dict[str, Any], Awaitable[None]], ) -> None: """Test service call that adds an event with a date time range.""" mock_calendars_list({"items": [test_api_calendar]}) mock_events_list({}) assert await component_setup() start_datetime = datetime.datetime.now() delta = datetime.timedelta(days=3, hours=3) end_datetime = start_datetime + delta aioclient_mock.clear_requests() mock_insert_event( calendar_id=CALENDAR_ID, ) await add_event_call_service( { "start_date_time": start_datetime.isoformat(), "end_date_time": end_datetime.isoformat(), }, ) assert len(aioclient_mock.mock_calls) == 1 assert aioclient_mock.mock_calls[0][2] == { "summary": TEST_EVENT_SUMMARY, "description": TEST_EVENT_DESCRIPTION, "start": { "dateTime": start_datetime.isoformat(timespec="seconds"), "timeZone": "America/Regina", }, "end": { "dateTime": end_datetime.isoformat(timespec="seconds"), "timeZone": "America/Regina", }, }
async def test_failed_update_and_reconnection( hass: HomeAssistant, aioclient_mock: AiohttpClientMocker): """Test failed update and reconnection.""" mock_responses(aioclient_mock) assert await async_setup_component(hass, SENSOR_DOMAIN, {SENSOR_DOMAIN: ONE_SENSOR_CONFIG}) aioclient_mock.clear_requests() mock_responses(aioclient_mock, error=True) next_update = dt_util.utcnow() + timedelta(seconds=3) async_fire_time_changed(hass, next_update) await hass.async_block_till_done() assert hass.states.get("sensor.efergy_728386").state == STATE_UNAVAILABLE aioclient_mock.clear_requests() mock_responses(aioclient_mock) next_update = dt_util.utcnow() + timedelta(seconds=30) async_fire_time_changed(hass, next_update) await hass.async_block_till_done() assert hass.states.get("sensor.efergy_728386").state == "1628"
async def test_availability( opp: OpenPeerPower, aioclient_mock: AiohttpClientMocker ) -> None: """Test entity availability.""" now = dt_util.utcnow() with patch("openpeerpower.util.dt.utcnow", return_value=now): await setup_integration(opp, aioclient_mock) assert opp.states.get(UPCOMING_ENTITY_ID).state == "1" # state to unavailable aioclient_mock.clear_requests() mock_connection(aioclient_mock, error=True) future = now + timedelta(minutes=1) with patch("openpeerpower.util.dt.utcnow", return_value=future): async_fire_time_changed(opp, future) await opp.async_block_till_done() assert opp.states.get(UPCOMING_ENTITY_ID).state == STATE_UNAVAILABLE # state to available aioclient_mock.clear_requests() mock_connection(aioclient_mock) future += timedelta(minutes=1) with patch("openpeerpower.util.dt.utcnow", return_value=future): async_fire_time_changed(opp, future) await opp.async_block_till_done() assert opp.states.get(UPCOMING_ENTITY_ID).state == "1" # state to unavailable aioclient_mock.clear_requests() mock_connection(aioclient_mock, invalid_auth=True) future += timedelta(minutes=1) with patch("openpeerpower.util.dt.utcnow", return_value=future): async_fire_time_changed(opp, future) await opp.async_block_till_done() assert opp.states.get(UPCOMING_ENTITY_ID).state == STATE_UNAVAILABLE # state to available aioclient_mock.clear_requests() mock_connection(aioclient_mock) future += timedelta(minutes=1) with patch("openpeerpower.util.dt.utcnow", return_value=future): async_fire_time_changed(opp, future) await opp.async_block_till_done() assert opp.states.get(UPCOMING_ENTITY_ID).state == "1"
async def test_switch_error( hass: HomeAssistant, aioclient_mock: AiohttpClientMocker, caplog ) -> None: """Test error handling of the Modern Forms switches.""" await init_integration(hass, aioclient_mock) aioclient_mock.clear_requests() aioclient_mock.post("http://192.168.1.123:80/mf", text="", status=400) with patch("homeassistant.components.modern_forms.ModernFormsDevice.update"): await hass.services.async_call( SWITCH_DOMAIN, SERVICE_TURN_ON, {ATTR_ENTITY_ID: "switch.modernformsfan_away_mode"}, blocking=True, ) await hass.async_block_till_done() state = hass.states.get("switch.modernformsfan_away_mode") assert state.state == STATE_OFF assert "Invalid response from API" in caplog.text
async def test_no_alerts( hass: HomeAssistant, hass_ws_client, aioclient_mock: AiohttpClientMocker, ) -> None: """Test creating issues based on alerts.""" aioclient_mock.clear_requests() aioclient_mock.get( "https://alerts.home-assistant.io/alerts.json", text="", ) assert await async_setup_component(hass, DOMAIN, {}) client = await hass_ws_client(hass) await client.send_json({"id": 1, "type": "repairs/list_issues"}) msg = await client.receive_json() assert msg["success"] assert msg["result"] == {"issues": []}
async def test_add_event_date( hass: HomeAssistant, component_setup: ComponentSetup, mock_calendars_list: ApiResult, test_api_calendar: dict[str, Any], mock_insert_event: Callable[[str, dict[str, Any]], None], mock_events_list: ApiResult, setup_config_entry: MockConfigEntry, aioclient_mock: AiohttpClientMocker, add_event_call_service: Callable[dict[str, Any], Awaitable[None]], ) -> None: """Test service call that sets a date range.""" mock_calendars_list({"items": [test_api_calendar]}) mock_events_list({}) assert await component_setup() now = utcnow() today = now.date() end_date = today + datetime.timedelta(days=2) aioclient_mock.clear_requests() mock_insert_event( calendar_id=CALENDAR_ID, ) await add_event_call_service( { "start_date": today.isoformat(), "end_date": end_date.isoformat(), }, ) assert len(aioclient_mock.mock_calls) == 1 assert aioclient_mock.mock_calls[0][2] == { "summary": TEST_EVENT_SUMMARY, "description": TEST_EVENT_DESCRIPTION, "start": {"date": today.isoformat()}, "end": {"date": end_date.isoformat()}, }
async def test_add_event_date_in_x( hass: HomeAssistant, component_setup: ComponentSetup, mock_calendars_list: ApiResult, mock_insert_event: Callable[[..., dict[str, Any]], None], test_api_calendar: dict[str, Any], mock_events_list: ApiResult, date_fields: dict[str, Any], start_timedelta: datetime.timedelta, end_timedelta: datetime.timedelta, setup_config_entry: MockConfigEntry, aioclient_mock: AiohttpClientMocker, add_event_call_service: Callable[dict[str, Any], Awaitable[None]], ) -> None: """Test service call that adds an event with various time ranges.""" mock_calendars_list({"items": [test_api_calendar]}) mock_events_list({}) assert await component_setup() now = datetime.datetime.now() start_date = now + start_timedelta end_date = now + end_timedelta aioclient_mock.clear_requests() mock_insert_event( calendar_id=CALENDAR_ID, ) await add_event_call_service(date_fields) assert len(aioclient_mock.mock_calls) == 1 assert aioclient_mock.mock_calls[0][2] == { "summary": TEST_EVENT_SUMMARY, "description": TEST_EVENT_DESCRIPTION, "start": {"date": start_date.date().isoformat()}, "end": {"date": end_date.date().isoformat()}, }
async def test_data_manager_webhook_subscription( hass: HomeAssistant, component_factory: ComponentFactory, aioclient_mock: AiohttpClientMocker, ) -> None: """Test data manager webhook subscriptions.""" person0 = new_profile_config("person0", 0) await component_factory.configure_component(profile_configs=(person0, )) api: ConfigEntryWithingsApi = MagicMock(spec=ConfigEntryWithingsApi) data_manager = DataManager( hass, "person0", api, 0, WebhookConfig(id="1234", url="http://localhost/api/webhook/1234", enabled=True), ) # pylint: disable=protected-access data_manager._notify_subscribe_delay = datetime.timedelta(seconds=0) data_manager._notify_unsubscribe_delay = datetime.timedelta(seconds=0) api.notify_list.return_value = NotifyListResponse(profiles=( NotifyListProfile( appli=NotifyAppli.BED_IN, callbackurl="https://not.my.callback/url", expires=None, comment=None, ), NotifyListProfile( appli=NotifyAppli.BED_IN, callbackurl=data_manager.webhook_config.url, expires=None, comment=None, ), NotifyListProfile( appli=NotifyAppli.BED_OUT, callbackurl=data_manager.webhook_config.url, expires=None, comment=None, ), )) aioclient_mock.clear_requests() aioclient_mock.request( "HEAD", data_manager.webhook_config.url, status=200, ) # Test subscribing await data_manager.async_subscribe_webhook() api.notify_subscribe.assert_any_call(data_manager.webhook_config.url, NotifyAppli.WEIGHT) api.notify_subscribe.assert_any_call(data_manager.webhook_config.url, NotifyAppli.CIRCULATORY) api.notify_subscribe.assert_any_call(data_manager.webhook_config.url, NotifyAppli.ACTIVITY) api.notify_subscribe.assert_any_call(data_manager.webhook_config.url, NotifyAppli.SLEEP) try: api.notify_subscribe.assert_any_call(data_manager.webhook_config.url, NotifyAppli.USER) assert False except AssertionError: pass try: api.notify_subscribe.assert_any_call(data_manager.webhook_config.url, NotifyAppli.BED_IN) assert False except AssertionError: pass try: api.notify_subscribe.assert_any_call(data_manager.webhook_config.url, NotifyAppli.BED_OUT) assert False except AssertionError: pass # Test unsubscribing. await data_manager.async_unsubscribe_webhook() api.notify_revoke.assert_any_call(data_manager.webhook_config.url, NotifyAppli.BED_IN) api.notify_revoke.assert_any_call(data_manager.webhook_config.url, NotifyAppli.BED_OUT)
async def test_sensor_available( aioclient_mock: AiohttpClientMocker, hass: HomeAssistant ) -> None: """Test that the sensors are working.""" # Totals Test aioclient_mock.get( "https://kubra.io/stormcenter/api/v1/stormcenters/39e6d9f3-fdea-4539-848f-b8631945da6f/views/74de8a50-3f45-4f6a-9483-fd618bb9165d/currentState?preview=false", json={"data": {"interval_generation_data": "data/TEST"}}, ) aioclient_mock.get( "https://kubra.io/data/TEST/public/reports/a36a6292-1c55-44de-a6a9-44fedf9482ee_report.json", json={ "file_data": { "totals": { "cust_a": { "val": 123, }, "percent_cust_a": { "val": 1.23, }, "n_out": 456, "cust_s": 789, } } }, ) config_entry = MockConfigEntry(domain=DOMAIN, data=MOCK_ENTRY_DATA) config_entry.add_to_hass(hass) assert await hass.config_entries.async_setup(config_entry.entry_id) await hass.async_block_till_done() assert hass.data[DOMAIN] entries = hass.config_entries.async_entries(DOMAIN) assert len(entries) == 1 assert config_entry.state == ConfigEntryState.LOADED sensors_to_get = [ "total_customers_out", "total_percent_customers_out", "total_outage_count", "total_customers_served", ] for sensor in sensors_to_get: sensor_entity = hass.states.get(f"sensor.{sensor}") assert sensor_entity is not None assert sensor_entity.state != "unavailable" if sensor == "total_customers_out": assert sensor_entity.state == "123" elif sensor == "total_percent_customers_out": assert sensor_entity.state == "15.589" elif sensor == "total_outage_count": assert sensor_entity.state == "456" elif sensor == "total_customers_served": assert sensor_entity.state == "789" # County Test aioclient_mock.clear_requests() aioclient_mock.get( "https://kubra.io/stormcenter/api/v1/stormcenters/39e6d9f3-fdea-4539-848f-b8631945da6f/views/74de8a50-3f45-4f6a-9483-fd618bb9165d/currentState?preview=false", json={"data": {"interval_generation_data": "data/TEST"}}, ) aioclient_mock.get( "https://kubra.io/data/TEST/public/reports/a36a6292-1c55-44de-a6a9-44fedf9482ee_report.json", json={ "file_data": { "areas": [ { "name": "BUCKS", "cust_a": { "val": 123, }, "percent_cust_a": { "val": 1.23, }, "n_out": 456, "cust_s": 789, } ] } }, ) config_entry = MockConfigEntry(domain=DOMAIN, data=COUNTY_ENTRY_DATA) config_entry.add_to_hass(hass) assert await hass.config_entries.async_setup(config_entry.entry_id) await hass.async_block_till_done() assert hass.data[DOMAIN] entries = hass.config_entries.async_entries(DOMAIN) assert len(entries) == 2 assert config_entry.state == ConfigEntryState.LOADED sensors_to_get = [ "bucks_customers_out", "bucks_percent_customers_out", "bucks_outage_count", "bucks_customers_served", ] for sensor in sensors_to_get: sensor_entity = hass.states.get(f"sensor.{sensor}") assert sensor_entity is not None assert sensor_entity.state != "unavailable" if sensor == "bucks_customers_out": assert sensor_entity.state == "123" elif sensor == "bucks_percent_customers_out": assert sensor_entity.state == "15.589" elif sensor == "bucks_outage_count": assert sensor_entity.state == "456" elif sensor == "bucks_customers_served": assert sensor_entity.state == "789"
async def test_alerts_change( hass: HomeAssistant, hass_ws_client, aioclient_mock: AiohttpClientMocker, ha_version: str, fixture_1: str, expected_alerts_1: list[tuple(str, str)], fixture_2: str, expected_alerts_2: list[tuple(str, str)], ) -> None: """Test creating issues based on alerts.""" fixture_1_content = load_fixture(fixture_1, "homeassistant_alerts") aioclient_mock.clear_requests() aioclient_mock.get( "https://alerts.home-assistant.io/alerts.json", text=fixture_1_content, ) for alert in json.loads(fixture_1_content): stub_alert(aioclient_mock, alert["filename"]) activated_components = ( "aladdin_connect", "darksky", "hikvision", "hikvisioncam", "hive", "homematicip_cloud", "logi_circle", "neato", "nest", "senseme", "sochain", ) for domain in activated_components: hass.config.components.add(domain) with patch( "homeassistant.components.homeassistant_alerts.__version__", ha_version, ): assert await async_setup_component(hass, DOMAIN, {}) now = dt_util.utcnow() client = await hass_ws_client(hass) await client.send_json({"id": 1, "type": "repairs/list_issues"}) msg = await client.receive_json() assert msg["success"] assert_lists_same( msg["result"]["issues"], [{ "breaks_in_ha_version": None, "created": ANY, "dismissed_version": None, "domain": "homeassistant_alerts", "ignored": False, "is_fixable": False, "issue_id": f"{alert}_{integration}", "issue_domain": integration, "learn_more_url": None, "severity": "warning", "translation_key": "alert", "translation_placeholders": { "title": f"Title for {alert}", "description": f"Content for {alert}", }, } for alert, integration in expected_alerts_1], ) fixture_2_content = load_fixture(fixture_2, "homeassistant_alerts") aioclient_mock.clear_requests() aioclient_mock.get( "https://alerts.home-assistant.io/alerts.json", text=fixture_2_content, ) for alert in json.loads(fixture_2_content): stub_alert(aioclient_mock, alert["filename"]) future = now + UPDATE_INTERVAL + timedelta(seconds=1) async_fire_time_changed(hass, future) await hass.async_block_till_done() await client.send_json({"id": 2, "type": "repairs/list_issues"}) msg = await client.receive_json() assert msg["success"] assert_lists_same( msg["result"]["issues"], [{ "breaks_in_ha_version": None, "created": ANY, "dismissed_version": None, "domain": "homeassistant_alerts", "ignored": False, "is_fixable": False, "issue_id": f"{alert}_{integration}", "issue_domain": integration, "learn_more_url": None, "severity": "warning", "translation_key": "alert", "translation_placeholders": { "title": f"Title for {alert}", "description": f"Content for {alert}", }, } for alert, integration in expected_alerts_2], )