async def test_bulb_off_while_adding_in_ha(opp: OpenPeerPower): """Test Yeelight off while adding to ha, for example on OPP start.""" config_entry = MockConfigEntry( domain=DOMAIN, data={ **CONFIG_ENTRY_DATA, CONF_HOST: IP_ADDRESS, }, unique_id=ID, ) config_entry.add_to_opp(opp) mocked_bulb = _mocked_bulb(True) mocked_bulb.bulb_type = BulbType.WhiteTempMood with patch(f"{MODULE}.Bulb", return_value=mocked_bulb), patch( f"{MODULE}.config_flow.yeelight.Bulb", return_value=mocked_bulb): assert await opp.config_entries.async_setup(config_entry.entry_id) await opp.async_block_till_done() binary_sensor_entity_id = ENTITY_BINARY_SENSOR_TEMPLATE.format( IP_ADDRESS.replace(".", "_")) entity_registry = er.async_get(opp) assert entity_registry.async_get(binary_sensor_entity_id) is None type(mocked_bulb).get_capabilities = MagicMock(CAPABILITIES) type(mocked_bulb).get_properties = MagicMock(None) opp.data[DOMAIN][DATA_CONFIG_ENTRIES][ config_entry.entry_id][DATA_DEVICE].update() await opp.async_block_till_done() await opp.async_block_till_done() entity_registry = er.async_get(opp) assert entity_registry.async_get(binary_sensor_entity_id) is not None
async def test_unique_ids_entry(opp: OpenPeerPower): """Test Yeelight unique IDs from entry IDs.""" config_entry = MockConfigEntry( domain=DOMAIN, data={ **CONFIG_ENTRY_DATA, CONF_NIGHTLIGHT_SWITCH: True, }, ) config_entry.add_to_opp(opp) mocked_bulb = _mocked_bulb() mocked_bulb.bulb_type = BulbType.WhiteTempMood with _patch_discovery(MODULE), patch(f"{MODULE}.Bulb", return_value=mocked_bulb): assert await opp.config_entries.async_setup(config_entry.entry_id) await opp.async_block_till_done() entity_registry = er.async_get(opp) assert (entity_registry.async_get(ENTITY_BINARY_SENSOR).unique_id == f"{config_entry.entry_id}-nightlight_sensor") assert entity_registry.async_get( ENTITY_LIGHT).unique_id == config_entry.entry_id assert (entity_registry.async_get(ENTITY_NIGHTLIGHT).unique_id == f"{config_entry.entry_id}-nightlight") assert (entity_registry.async_get(ENTITY_AMBILIGHT).unique_id == f"{config_entry.entry_id}-ambilight")
async def test_ws_create(opp, opp_ws_client, storage_setup): """Test create WS.""" assert await storage_setup(items=[]) input_id = "new_input" input_entity_id = f"{DOMAIN}.{input_id}" ent_reg = er.async_get(opp) state = opp.states.get(input_entity_id) assert state is None assert ent_reg.async_get_entity_id(DOMAIN, DOMAIN, input_id) is None client = await opp_ws_client(opp) await client.send_json({ "id": 6, "type": f"{DOMAIN}/create", "name": "New Input", "latitude": 3, "longitude": 4, "passive": True, }) resp = await client.receive_json() assert resp["success"] state = opp.states.get(input_entity_id) assert state.state == "zoning" assert state.attributes["latitude"] == 3 assert state.attributes["longitude"] == 4 assert state.attributes["passive"] is True
async def test_cleanup_entity_registry_change(opp): """Test we run a cleanup when entity registry changes. Don't pre-load the registries as the debouncer will then not be waiting for EVENT_ENTITY_REGISTRY_UPDATED events. """ await device_registry.async_load(opp) await entity_registry.async_load(opp) ent_reg = entity_registry.async_get(opp) with patch("openpeerpower.helpers.device_registry.Debouncer.async_call" ) as mock_call: entity = ent_reg.async_get_or_create("light", "hue", "e1") await opp.async_block_till_done() assert len(mock_call.mock_calls) == 0 # Normal update does not trigger ent_reg.async_update_entity(entity.entity_id, name="updated") await opp.async_block_till_done() assert len(mock_call.mock_calls) == 0 # Device ID update triggers ent_reg.async_get_or_create("light", "hue", "e1", device_id="bla") await opp.async_block_till_done() assert len(mock_call.mock_calls) == 1 # Removal also triggers ent_reg.async_remove(entity.entity_id) await opp.async_block_till_done() assert len(mock_call.mock_calls) == 2
async def test_cleanup_device_registry(opp, registry): """Test cleanup works.""" config_entry = MockConfigEntry(domain="hue") config_entry.add_to_opp(opp) d1 = registry.async_get_or_create(identifiers={("hue", "d1")}, config_entry_id=config_entry.entry_id) registry.async_get_or_create(identifiers={("hue", "d2")}, config_entry_id=config_entry.entry_id) d3 = registry.async_get_or_create(identifiers={("hue", "d3")}, config_entry_id=config_entry.entry_id) registry.async_get_or_create(identifiers={("something", "d4")}, config_entry_id="non_existing") ent_reg = entity_registry.async_get(opp) ent_reg.async_get_or_create("light", "hue", "e1", device_id=d1.id) ent_reg.async_get_or_create("light", "hue", "e2", device_id=d1.id) ent_reg.async_get_or_create("light", "hue", "e3", device_id=d3.id) device_registry.async_cleanup(opp, registry, ent_reg) assert registry.async_get_device({("hue", "d1")}) is not None assert registry.async_get_device({("hue", "d2")}) is not None assert registry.async_get_device({("hue", "d3")}) is not None assert registry.async_get_device({("something", "d4")}) is None
async def _create_entries( opp: OpenPeerPower, client=None) -> tuple[RegistryEntry, DeviceEntry, ClientMock]: client = ClientMock() if client is None else client def get_client_mock(client, _): return client with patch("twinkly_client.TwinklyClient", side_effect=get_client_mock): config_entry = MockConfigEntry( domain=TWINKLY_DOMAIN, data={ CONF_ENTRY_HOST: client, CONF_ENTRY_ID: client.id, CONF_ENTRY_NAME: TEST_NAME_ORIGINAL, CONF_ENTRY_MODEL: TEST_MODEL, }, entry_id=client.id, ) config_entry.add_to_opp(opp) assert await opp.config_entries.async_setup(client.id) await opp.async_block_till_done() device_registry = dr.async_get(opp) entity_registry = er.async_get(opp) entity_id = entity_registry.async_get_entity_id("light", TWINKLY_DOMAIN, client.id) entity = entity_registry.async_get(entity_id) device = device_registry.async_get_device({(TWINKLY_DOMAIN, client.id)}) assert entity is not None assert device is not None return entity, device, client
async def test_simpleconnect_fan_setup(opp): """Test that a SIMPLEconnect fan can be correctly setup in HA.""" accessories = await setup_accessories_from_file(opp, "simpleconnect_fan.json") config_entry, pairing = await setup_test_accessories(opp, accessories) entity_registry = er.async_get(opp) # Check that the fan is correctly found and set up fan_id = "fan.simpleconnect_fan_06f674" fan = entity_registry.async_get(fan_id) assert fan.unique_id == "homekit-1234567890abcd-8" fan_helper = Helper( opp, "fan.simpleconnect_fan_06f674", pairing, accessories[0], config_entry, ) fan_state = await fan_helper.poll_and_get_state() assert fan_state.attributes["friendly_name"] == "SIMPLEconnect Fan-06F674" assert fan_state.state == "off" assert fan_state.attributes["supported_features"] == (SUPPORT_DIRECTION | SUPPORT_SET_SPEED) device_registry = dr.async_get(opp) device = device_registry.async_get(fan.device_id) assert device.manufacturer == "Hunter Fan" assert device.name == "SIMPLEconnect Fan-06F674" assert device.model == "SIMPLEconnect" assert device.sw_version == "" assert device.via_device_id is None
async def test_restoring_devices(opp): """Test restoring existing device_tracker entities if not detected on startup.""" config_entry = MockConfigEntry(domain=mikrotik.DOMAIN, data=MOCK_DATA, options=MOCK_OPTIONS) config_entry.add_to_opp(opp) registry = er.async_get(opp) registry.async_get_or_create( device_tracker.DOMAIN, mikrotik.DOMAIN, "00:00:00:00:00:01", suggested_object_id="device_1", config_entry=config_entry, ) registry.async_get_or_create( device_tracker.DOMAIN, mikrotik.DOMAIN, "00:00:00:00:00:02", suggested_object_id="device_2", config_entry=config_entry, ) await setup_mikrotik_entry(opp) # test device_2 which is not in wireless list is restored device_1 = opp.states.get("device_tracker.device_1") assert device_1 is not None assert device_1.state == "home" device_2 = opp.states.get("device_tracker.device_2") assert device_2 is not None assert device_2.state == "not_home"
async def test_entity_registry(opp): """Tests that the devices are registered in the entity registry.""" await setup_platform(opp, COVER_DOMAIN) entity_registry = er.async_get(opp) entry = entity_registry.async_get(DEVICE_ID) assert entry.unique_id == "61cbz3b542d2o33ed2fz02721bda3324"
async def test_hmip_remove_device(opp, default_mock_hap_factory): """Test Remove of hmip device.""" entity_id = "light.treppe_ch" entity_name = "Treppe CH" device_model = "HmIP-BSL" mock_hap = await default_mock_hap_factory.async_get_mock_hap( test_devices=["Treppe"] ) ha_state, hmip_device = get_and_check_entity_basics( opp, mock_hap, entity_id, entity_name, device_model ) assert ha_state.state == STATE_ON assert hmip_device device_registry = dr.async_get(opp) entity_registry = er.async_get(opp) pre_device_count = len(device_registry.devices) pre_entity_count = len(entity_registry.entities) pre_mapping_count = len(mock_hap.hmip_device_by_entity_id) hmip_device.fire_remove_event() await opp.async_block_till_done() assert len(device_registry.devices) == pre_device_count - 1 assert len(entity_registry.entities) == pre_entity_count - 3 assert len(mock_hap.hmip_device_by_entity_id) == pre_mapping_count - 3
async def test_hmip_multi_area_device(opp, default_mock_hap_factory): """Test multi area device. Check if devices are created and referenced.""" entity_id = "binary_sensor.wired_eingangsmodul_32_fach_channel5" entity_name = "Wired Eingangsmodul – 32-fach Channel5" device_model = "HmIPW-DRI32" mock_hap = await default_mock_hap_factory.async_get_mock_hap( test_devices=["Wired Eingangsmodul – 32-fach"] ) ha_state, hmip_device = get_and_check_entity_basics( opp, mock_hap, entity_id, entity_name, device_model ) assert ha_state # get the entity entity_registry = er.async_get(opp) entity = entity_registry.async_get(ha_state.entity_id) assert entity # get the device device_registry = dr.async_get(opp) device = device_registry.async_get(entity.device_id) assert device.name == "Wired Eingangsmodul – 32-fach" # get the hap hap_device = device_registry.async_get(device.via_device_id) assert hap_device.name == "Home"
async def test_hmip_remove_group(opp, default_mock_hap_factory): """Test Remove of hmip group.""" entity_id = "switch.strom_group" entity_name = "Strom Group" device_model = None mock_hap = await default_mock_hap_factory.async_get_mock_hap(test_groups=["Strom"]) ha_state, hmip_device = get_and_check_entity_basics( opp, mock_hap, entity_id, entity_name, device_model ) assert ha_state.state == STATE_ON assert hmip_device device_registry = dr.async_get(opp) entity_registry = er.async_get(opp) pre_device_count = len(device_registry.devices) pre_entity_count = len(entity_registry.entities) pre_mapping_count = len(mock_hap.hmip_device_by_entity_id) hmip_device.fire_remove_event() await opp.async_block_till_done() assert len(device_registry.devices) == pre_device_count assert len(entity_registry.entities) == pre_entity_count - 1 assert len(mock_hap.hmip_device_by_entity_id) == pre_mapping_count - 1
async def test_backupsses600m1(opp): """Test creation of BACKUPSES600M1 sensors.""" await async_init_integration(opp, "BACKUPSES600M1", ["battery.charge"]) registry = er.async_get(opp) entry = registry.async_get("sensor.ups1_battery_charge") assert entry assert ( entry.unique_id == "American Power Conversion_Back-UPS ES 600M1_4B1713P32195 _battery.charge" ) state = opp.states.get("sensor.ups1_battery_charge") assert state.state == "100" expected_attributes = { "device_class": "battery", "friendly_name": "Ups1 Battery Charge", "state": "Online", "unit_of_measurement": PERCENTAGE, } # Only test for a subset of attributes in case # OPP changes the implementation and a new one appears assert all(state.attributes[key] == expected_attributes[key] for key in expected_attributes)
async def test_entity_registry(opp): """Tests that the devices are registered in the entity registry.""" await setup_platform(opp, SENSOR_DOMAIN) entity_registry = er.async_get(opp) entry = entity_registry.async_get("sensor.environment_sensor_humidity") assert entry.unique_id == "13545b21f4bdcd33d9abd461f8443e65-humidity"
async def test_aqara_switch_setup(opp): """Test that a Aqara Switch can be correctly setup in HA.""" accessories = await setup_accessories_from_file(opp, "aqara_switch.json") config_entry, pairing = await setup_test_accessories(opp, accessories) entity_registry = er.async_get(opp) battery_id = "sensor.programmable_switch_battery" battery = entity_registry.async_get(battery_id) assert battery.unique_id == "homekit-111a1111a1a111-5" # The fixture file has 1 button and a battery expected = [{ "device_id": battery.device_id, "domain": "sensor", "entity_id": "sensor.programmable_switch_battery", "platform": "device", "type": "battery_level", }] for subtype in ("single_press", "double_press", "long_press"): expected.append({ "device_id": battery.device_id, "domain": "homekit_controller", "platform": "device", "type": "button1", "subtype": subtype, }) triggers = await async_get_device_automations(opp, "trigger", battery.device_id) assert_lists_same(triggers, expected)
async def test_sensor_restore(opp, hk_driver, events): """Test setting up an entity from state in the event registry.""" opp.state = CoreState.not_running registry = er.async_get(opp) registry.async_get_or_create( "sensor", "generic", "1234", suggested_object_id="temperature", device_class="temperature", ) registry.async_get_or_create( "sensor", "generic", "12345", suggested_object_id="humidity", device_class="humidity", unit_of_measurement=PERCENTAGE, ) opp.bus.async_fire(EVENT_OPENPEERPOWER_START, {}) await opp.async_block_till_done() acc = get_accessory(opp, hk_driver, opp.states.get("sensor.temperature"), 2, {}) assert acc.category == 10 acc = get_accessory(opp, hk_driver, opp.states.get("sensor.humidity"), 2, {}) assert acc.category == 10
async def test_lights_can_be_enabled(opp: OpenPeerPower) -> None: """Verify lights can be enabled.""" client = create_mock_client() await setup_test_config_entry(opp, hyperion_client=client) entity_registry = er.async_get(opp) entry = entity_registry.async_get(TEST_PRIORITY_LIGHT_ENTITY_ID_1) assert entry assert entry.disabled assert entry.disabled_by == er.DISABLED_INTEGRATION entity_state = opp.states.get(TEST_PRIORITY_LIGHT_ENTITY_ID_1) assert not entity_state with patch( "openpeerpower.components.hyperion.client.HyperionClient", return_value=client, ): updated_entry = entity_registry.async_update_entity( TEST_PRIORITY_LIGHT_ENTITY_ID_1, disabled_by=None) assert not updated_entry.disabled await opp.async_block_till_done() async_fire_time_changed( # type: ignore[no-untyped-call] opp, dt.utcnow() + timedelta(seconds=RELOAD_AFTER_UPDATE_DELAY + 1), ) await opp.async_block_till_done() entity_state = opp.states.get(TEST_PRIORITY_LIGHT_ENTITY_ID_1) assert entity_state
async def test_entity_registry(opp): """Tests that the devices are registered in the entity registry.""" await setup_platform(opp, LOCK_DOMAIN) entity_registry = er.async_get(opp) entry = entity_registry.async_get(DEVICE_ID) assert entry.unique_id == "51cab3b545d2o34ed7fz02731bda5324"
async def test_simpleconnect_cover_setup(opp): """Test that a velux gateway can be correctly setup in HA.""" accessories = await setup_accessories_from_file(opp, "velux_gateway.json") config_entry, pairing = await setup_test_accessories(opp, accessories) entity_registry = er.async_get(opp) # Check that the cover is correctly found and set up cover_id = "cover.velux_window" cover = entity_registry.async_get(cover_id) assert cover.unique_id == "homekit-1111111a114a111a-8" cover_helper = Helper( opp, cover_id, pairing, accessories[0], config_entry, ) cover_state = await cover_helper.poll_and_get_state() assert cover_state.attributes["friendly_name"] == "VELUX Window" assert cover_state.state == "closed" assert cover_state.attributes["supported_features"] == ( SUPPORT_CLOSE | SUPPORT_SET_POSITION | SUPPORT_OPEN ) # Check that one of the sensors is correctly found and set up sensor_id = "sensor.velux_sensor_temperature" sensor = entity_registry.async_get(sensor_id) assert sensor.unique_id == "homekit-a11b111-8" sensor_helper = Helper( opp, sensor_id, pairing, accessories[0], config_entry, ) sensor_state = await sensor_helper.poll_and_get_state() assert sensor_state.attributes["friendly_name"] == "VELUX Sensor Temperature" assert sensor_state.state == "18.9" # The cover and sensor are different devices (accessories) attached to the same bridge assert cover.device_id != sensor.device_id device_registry = dr.async_get(opp) device = device_registry.async_get(cover.device_id) assert device.manufacturer == "VELUX" assert device.name == "VELUX Window" assert device.model == "VELUX Window" assert device.sw_version == "48" bridge = device_registry.async_get(device.via_device_id) assert bridge.manufacturer == "VELUX" assert bridge.name == "VELUX Gateway" assert bridge.model == "VELUX Gateway" assert bridge.sw_version == "70"
async def test_migration(opp): """Test migration from old data to new.""" mock_config = MockConfigEntry(domain="test-platform", entry_id="test-config-id") old_conf = { "light.kitchen": { "config_entry_id": "test-config-id", "unique_id": "test-unique", "platform": "test-platform", "name": "Test Name", "disabled_by": er.DISABLED_OPP, } } with patch("os.path.isfile", return_value=True), patch("os.remove"), patch( "openpeerpower.helpers.entity_registry.load_yaml", return_value=old_conf): await er.async_load(opp) registry = er.async_get(opp) assert registry.async_is_registered("light.kitchen") entry = registry.async_get_or_create( domain="light", platform="test-platform", unique_id="test-unique", config_entry=mock_config, ) assert entry.name == "Test Name" assert entry.disabled_by == er.DISABLED_OPP assert entry.config_entry_id == "test-config-id"
async def async_configure_accessories(self): """Configure accessories for the included states.""" dev_reg = device_registry.async_get(self.opp) ent_reg = entity_registry.async_get(self.opp) device_lookup = ent_reg.async_get_device_class_lookup({ (BINARY_SENSOR_DOMAIN, DEVICE_CLASS_BATTERY_CHARGING), (BINARY_SENSOR_DOMAIN, DEVICE_CLASS_MOTION), (BINARY_SENSOR_DOMAIN, DEVICE_CLASS_OCCUPANCY), (SENSOR_DOMAIN, DEVICE_CLASS_BATTERY), (SENSOR_DOMAIN, DEVICE_CLASS_HUMIDITY), }) entity_states = [] for state in self.opp.states.async_all(): entity_id = state.entity_id if not self._filter(entity_id): continue ent_reg_ent = ent_reg.async_get(entity_id) if ent_reg_ent: await self._async_set_device_info_attributes( ent_reg_ent, dev_reg, entity_id) self._async_configure_linked_sensors(ent_reg_ent, device_lookup, state) entity_states.append(state) return entity_states
async def test_state(opp): """Test state of the entity.""" mocked_device = _create_mocked_device() entry = MockConfigEntry(domain=songpal.DOMAIN, data=CONF_DATA) entry.add_to_opp(opp) with _patch_media_player_device(mocked_device): await opp.config_entries.async_setup(entry.entry_id) await opp.async_block_till_done() state = opp.states.get(ENTITY_ID) assert state.name == FRIENDLY_NAME assert state.state == STATE_ON attributes = state.as_dict()["attributes"] assert attributes["volume_level"] == 0.5 assert attributes["is_volume_muted"] is False assert attributes["source_list"] == ["title1", "title2"] assert attributes["source"] == "title2" assert attributes["supported_features"] == SUPPORT_SONGPAL device_registry = dr.async_get(opp) device = device_registry.async_get_device(identifiers={(songpal.DOMAIN, MAC)}) assert device.connections == {(dr.CONNECTION_NETWORK_MAC, MAC)} assert device.manufacturer == "Sony Corporation" assert device.name == FRIENDLY_NAME assert device.sw_version == SW_VERSION assert device.model == MODEL entity_registry = er.async_get(opp) entity = entity_registry.async_get(ENTITY_ID) assert entity.unique_id == MAC
async def test_ws_create(opp, opp_ws_client, storage_setup): """Test create WS.""" assert await storage_setup(items=[]) input_id = "new_input" input_entity_id = f"{DOMAIN}.{input_id}" ent_reg = er.async_get(opp) state = opp.states.get(input_entity_id) assert state is None assert ent_reg.async_get_entity_id(DOMAIN, DOMAIN, input_id) is None client = await opp_ws_client(opp) await client.send_json({ "id": 6, "type": f"{DOMAIN}/create", "name": "New Input", "max": 20, "min": 0, "initial": 10, "step": 1, "mode": "slider", }) resp = await client.receive_json() assert resp["success"] state = opp.states.get(input_entity_id) assert float(state.state) == 10
async def test_ws_create(opp, opp_ws_client, storage_setup): """Test create WS.""" assert await storage_setup(items=[]) input_id = "new_input" input_entity_id = f"{DOMAIN}.{input_id}" ent_reg = er.async_get(opp) state = opp.states.get(input_entity_id) assert state is None assert ent_reg.async_get_entity_id(DOMAIN, DOMAIN, input_id) is None client = await opp_ws_client(opp) await client.send_json( { "id": 6, "type": f"{DOMAIN}/create", "name": "New Input", "initial": "even newer option", ATTR_MAX: 44, } ) resp = await client.receive_json() assert resp["success"] state = opp.states.get(input_entity_id) assert state.state == "even newer option" assert state.attributes[ATTR_FRIENDLY_NAME] == "New Input" assert state.attributes[ATTR_EDITABLE] assert state.attributes[ATTR_MAX] == 44 assert state.attributes[ATTR_MIN] == 0
async def test_cleanup_device_registry_removes_expired_orphaned_devices( opp, registry): """Test cleanup removes expired orphaned devices.""" config_entry = MockConfigEntry(domain="hue") config_entry.add_to_opp(opp) registry.async_get_or_create(identifiers={("hue", "d1")}, config_entry_id=config_entry.entry_id) registry.async_get_or_create(identifiers={("hue", "d2")}, config_entry_id=config_entry.entry_id) registry.async_get_or_create(identifiers={("hue", "d3")}, config_entry_id=config_entry.entry_id) registry.async_clear_config_entry(config_entry.entry_id) assert len(registry.devices) == 0 assert len(registry.deleted_devices) == 3 ent_reg = entity_registry.async_get(opp) device_registry.async_cleanup(opp, registry, ent_reg) assert len(registry.devices) == 0 assert len(registry.deleted_devices) == 3 future_time = time.time( ) + device_registry.ORPHANED_DEVICE_KEEP_SECONDS + 1 with patch("time.time", return_value=future_time): device_registry.async_cleanup(opp, registry, ent_reg) assert len(registry.devices) == 0 assert len(registry.deleted_devices) == 0
async def test_sensors(opp: OpenPeerPower, device: DysonPureCoolLink, sensors: list[str]) -> None: """Test the sensors.""" # Temperature is given by the device in kelvin # Make sure no other sensors are set up assert len(opp.states.async_all()) == len(sensors) entity_registry = er.async_get(opp) for sensor in sensors: entity_id = _async_get_entity_id(sensor) # Test unique id assert entity_registry.async_get( entity_id).unique_id == f"{SERIAL}-{sensor}" # Test state state = opp.states.get(entity_id) assert state.state == str(MOCKED_VALUES[sensor]) assert state.name == f"{NAME} {SENSOR_NAMES[sensor]}" # Test attributes attributes = state.attributes for attr, value in SENSOR_ATTRIBUTES[sensor].items(): assert attributes[attr] == value # Test data update _async_assign_values(device, MOCKED_UPDATED_VALUES) await async_update_device(opp, device) for sensor in sensors: state = opp.states.get(_async_get_entity_id(sensor)) assert state.state == str(MOCKED_UPDATED_VALUES[sensor])
async def test_ws_delete(opp, opp_ws_client, storage_setup): """Test WS delete cleans up entity registry.""" assert await storage_setup() input_id = "from_storage" input_entity_id = f"{DOMAIN}.{input_id}" ent_reg = er.async_get(opp) state = opp.states.get(input_entity_id) assert state is not None assert ent_reg.async_get_entity_id(DOMAIN, DOMAIN, input_id) is not None client = await opp_ws_client(opp) await client.send_json({ "id": 6, "type": f"{DOMAIN}/delete", f"{DOMAIN}_id": f"{input_id}" }) resp = await client.receive_json() assert resp["success"] state = opp.states.get(input_entity_id) assert state is None assert ent_reg.async_get_entity_id(DOMAIN, DOMAIN, input_id) is None
async def test_config_parameter_sensor(opp, lock_id_lock_as_id150, integration): """Test config parameter sensor is created.""" ent_reg = er.async_get(opp) entity_entry = ent_reg.async_get(ID_LOCK_CONFIG_PARAMETER_SENSOR) assert entity_entry assert entity_entry.disabled
async def test_enter_and_exit(opp, gpslogger_client, webhook_id): """Test when there is a known zone.""" url = f"/api/webhook/{webhook_id}" data = {"latitude": HOME_LATITUDE, "longitude": HOME_LONGITUDE, "device": "123"} # Enter the Home req = await gpslogger_client.post(url, data=data) await opp.async_block_till_done() assert req.status == HTTP_OK state_name = opp.states.get(f"{DEVICE_TRACKER_DOMAIN}.{data['device']}").state assert state_name == STATE_HOME # Enter Home again req = await gpslogger_client.post(url, data=data) await opp.async_block_till_done() assert req.status == HTTP_OK state_name = opp.states.get(f"{DEVICE_TRACKER_DOMAIN}.{data['device']}").state assert state_name == STATE_HOME data["longitude"] = 0 data["latitude"] = 0 # Enter Somewhere else req = await gpslogger_client.post(url, data=data) await opp.async_block_till_done() assert req.status == HTTP_OK state_name = opp.states.get(f"{DEVICE_TRACKER_DOMAIN}.{data['device']}").state assert state_name == STATE_NOT_HOME dev_reg = dr.async_get(opp) assert len(dev_reg.devices) == 1 ent_reg = er.async_get(opp) assert len(ent_reg.entities) == 1
async def test_koogeek_ls1_setup(opp): """Test that a Koogeek LS1 can be correctly setup in HA.""" accessories = await setup_accessories_from_file(opp, "koogeek_ls1.json") config_entry, pairing = await setup_test_accessories(opp, accessories) entity_registry = er.async_get(opp) # Assert that the entity is correctly added to the entity registry entry = entity_registry.async_get("light.koogeek_ls1_20833f") assert entry.unique_id == "homekit-AAAA011111111111-7" helper = Helper(opp, "light.koogeek_ls1_20833f", pairing, accessories[0], config_entry) state = await helper.poll_and_get_state() # Assert that the friendly name is detected correctly assert state.attributes["friendly_name"] == "Koogeek-LS1-20833F" # Assert that all optional features the LS1 supports are detected assert state.attributes["supported_features"] == (SUPPORT_BRIGHTNESS | SUPPORT_COLOR) device_registry = dr.async_get(opp) device = device_registry.async_get(entry.device_id) assert device.manufacturer == "Koogeek" assert device.name == "Koogeek-LS1-20833F" assert device.model == "LS1" assert device.sw_version == "2.2.15" assert device.via_device_id is None