async def test_cancel_wait_template(hass):
"""Test the cancelling while wait_template is present."""
event = "test_event"
events = async_capture_events(hass, event)
sequence = cv.SCRIPT_SCHEMA(
[
{"wait_template": "{{ states.switch.test.state == 'off' }}"},
{"event": event},
]
)
script_obj = script.Script(hass, sequence)
wait_started_flag = async_watch_for_action(script_obj, "wait")
try:
hass.states.async_set("switch.test", "on")
hass.async_create_task(script_obj.async_run())
await asyncio.wait_for(wait_started_flag.wait(), 1)
assert script_obj.is_running
assert len(events) == 0
except (AssertionError, asyncio.TimeoutError):
await script_obj.async_stop()
raise
else:
await script_obj.async_stop()
assert not script_obj.is_running
# Make sure the script is really stopped.
hass.states.async_set("switch.test", "off")
await hass.async_block_till_done()
assert not script_obj.is_running
assert len(events) == 0
async def test_wait_template_timeout(hass, mock_timeout, continue_on_timeout, n_events):
"""Test the wait template, halt on timeout."""
event = "test_event"
events = async_capture_events(hass, event)
sequence = [
{"wait_template": "{{ states.switch.test.state == 'off' }}", "timeout": 5},
{"event": event},
]
if continue_on_timeout is not None:
sequence[0]["continue_on_timeout"] = continue_on_timeout
sequence = cv.SCRIPT_SCHEMA(sequence)
script_obj = script.Script(hass, sequence)
wait_started_flag = async_watch_for_action(script_obj, "wait")
try:
hass.states.async_set("switch.test", "on")
hass.async_create_task(script_obj.async_run())
await asyncio.wait_for(wait_started_flag.wait(), 1)
assert script_obj.is_running
assert len(events) == 0
except (AssertionError, asyncio.TimeoutError):
await script_obj.async_stop()
raise
else:
async_fire_time_changed(hass, dt_util.utcnow() + timedelta(seconds=5))
await hass.async_block_till_done()
assert not script_obj.is_running
assert len(events) == n_events
async def test_if_fires_on_event(hass, calls, device_reg, entity_reg, platform,
camera_type, event_type):
"""Test for event triggers firing."""
mac_address = "12:34:56:AB:CD:EF"
connection = (device_registry.CONNECTION_NETWORK_MAC, mac_address)
config_entry = MockConfigEntry(domain=NETATMO_DOMAIN, data={})
config_entry.add_to_hass(hass)
device_entry = device_reg.async_get_or_create(
config_entry_id=config_entry.entry_id,
connections={connection},
identifiers={(NETATMO_DOMAIN, mac_address)},
model=camera_type,
)
entity_reg.async_get_or_create(platform,
NETATMO_DOMAIN,
"5678",
device_id=device_entry.id)
events = async_capture_events(hass, "netatmo_event")
assert await async_setup_component(
hass,
automation.DOMAIN,
{
automation.DOMAIN: [
{
"trigger": {
"platform": "device",
"domain": NETATMO_DOMAIN,
"device_id": device_entry.id,
"entity_id": f"{platform}.{NETATMO_DOMAIN}_5678",
"type": event_type,
},
"action": {
"service": "test.automation",
"data_template": {
"some":
("{{trigger.event.data.type}} - {{trigger.platform}} - {{trigger.event.data.device_id}}"
)
},
},
},
]
},
)
device = device_reg.async_get_device(set(), {connection})
assert device is not None
# Fake that the entity is turning on.
hass.bus.async_fire(
event_type=NETATMO_EVENT,
event_data={
"type": event_type,
ATTR_DEVICE_ID: device.id,
},
)
await hass.async_block_till_done()
assert len(events) == 1
assert len(calls) == 1
assert calls[0].data["some"] == f"{event_type} - device - {device.id}"
async def test_unknown_notification(hass, hank_binary_switch, integration,
client):
"""Test behavior of unknown notification type events."""
# just pick a random node to fake the notification event
node = hank_binary_switch
# We emit the event directly so we can skip any validation and event handling
# by the lib. We will use a class that is guaranteed not to be recognized
notification_obj = AsyncMock()
notification_obj.node = node
with pytest.raises(TypeError):
node.emit("notification", {"notification": notification_obj})
notification_events = async_capture_events(hass, "zwave_js_notification")
# Test a valid notification with an unsupported command class
event = Event(
type="notification",
data={
"source": "node",
"event": "notification",
"nodeId": node.node_id,
"ccId": 0,
"args": {
"commandClassName": "No Operation",
"commandClass": 0,
"testNodeId": 1,
"status": 0,
"acknowledgedFrames": 2,
},
},
)
node.receive_event(event)
assert not notification_events
async def test_power_level_notification(hass, hank_binary_switch, integration,
client):
"""Test power level notification events."""
# just pick a random node to fake the notification event
node = hank_binary_switch
events = async_capture_events(hass, "zwave_js_notification")
event = Event(
type="notification",
data={
"source": "node",
"event": "notification",
"nodeId": 7,
"ccId": 115,
"args": {
"commandClassName": "Powerlevel",
"commandClass": 115,
"testNodeId": 1,
"status": 0,
"acknowledgedFrames": 2,
},
},
)
node.receive_event(event)
await hass.async_block_till_done()
assert len(events) == 1
assert events[0].data["command_class_name"] == "Powerlevel"
assert events[0].data["command_class"] == 115
assert events[0].data["test_node_id"] == 1
assert events[0].data["status"] == 0
assert events[0].data["acknowledged_frames"] == 2
async def test_repeat_count(hass):
"""Test repeat action w/ count option."""
event = "test_event"
events = async_capture_events(hass, event)
count = 3
sequence = cv.SCRIPT_SCHEMA(
{
"repeat": {
"count": count,
"sequence": {
"event": event,
"event_data_template": {
"first": "{{ repeat.first }}",
"index": "{{ repeat.index }}",
"last": "{{ repeat.last }}",
},
},
}
}
)
script_obj = script.Script(hass, sequence)
await script_obj.async_run()
await hass.async_block_till_done()
assert len(events) == count
for index, event in enumerate(events):
assert event.data.get("first") == str(index == 0)
assert event.data.get("index") == str(index + 1)
assert event.data.get("last") == str(index == count - 1)
async def test_condition_basic(hass, script_mode):
"""Test if we can use conditions in a script."""
event = "test_event"
events = async_capture_events(hass, event)
sequence = cv.SCRIPT_SCHEMA([
{
"event": event
},
{
"condition": "template",
"value_template": "{{ states.test.entity.state == 'hello' }}",
},
{
"event": event
},
])
script_obj = script.Script(hass, sequence, script_mode=script_mode)
assert script_obj.can_cancel == (script_mode != "legacy")
hass.states.async_set("test.entity", "hello")
await script_obj.async_run()
await hass.async_block_till_done()
assert len(events) == 2
hass.states.async_set("test.entity", "goodbye")
await script_obj.async_run()
await hass.async_block_till_done()
assert len(events) == 3
async def test_camera_sound_event(hass):
"""Test a pubsub message for a camera sound event."""
events = async_capture_events(hass, NEST_EVENT)
subscriber = await async_setup_devices(
hass,
"sdm.devices.types.CAMERA",
create_device_traits(["sdm.devices.traits.CameraSound"]),
)
registry = er.async_get(hass)
entry = registry.async_get("camera.front")
assert entry is not None
timestamp = utcnow()
await subscriber.async_receive_event(
create_event("sdm.devices.events.CameraSound.Sound", timestamp=timestamp)
)
await hass.async_block_till_done()
event_time = timestamp.replace(microsecond=0)
assert len(events) == 1
assert event_view(events[0].data) == {
"device_id": entry.device_id,
"type": "camera_sound",
"timestamp": event_time,
}
async def test_event_register(hass: HomeAssistant, knx: KNXTestKit):
"""Test `knx.event_register` service."""
events = async_capture_events(hass, "knx_event")
test_address = "1/2/3"
await knx.setup_integration({})
# no event registered
await knx.receive_write(test_address, True)
await hass.async_block_till_done()
assert len(events) == 0
# register event
await hass.services.async_call(
"knx", "event_register", {"address": test_address}, blocking=True
)
await knx.receive_write(test_address, True)
await knx.receive_write(test_address, False)
await hass.async_block_till_done()
assert len(events) == 2
# remove event registration - no event added
await hass.services.async_call(
"knx",
"event_register",
{"address": test_address, "remove": True},
blocking=True,
)
await knx.receive_write(test_address, True)
await hass.async_block_till_done()
assert len(events) == 2
async def test_doorbell_event_session_update(hass, subscriber, setup_platform):
"""Test a pubsub message with updates to an existing session."""
events = async_capture_events(hass, NEST_EVENT)
await setup_platform()
registry = er.async_get(hass)
entry = registry.async_get("camera.front")
assert entry is not None
# Message #1 has a motion event
timestamp1 = utcnow()
await subscriber.async_receive_event(
create_events(
{
"sdm.devices.events.CameraMotion.Motion": {
"eventSessionId": EVENT_SESSION_ID,
"eventId": "n:1",
},
"sdm.devices.events.CameraClipPreview.ClipPreview": {
"eventSessionId": EVENT_SESSION_ID,
"previewUrl": "image-url-1",
},
},
timestamp=timestamp1,
)
)
# Message #2 has an extra person event
timestamp2 = utcnow()
await subscriber.async_receive_event(
create_events(
{
"sdm.devices.events.CameraMotion.Motion": {
"eventSessionId": EVENT_SESSION_ID,
"eventId": "n:1",
},
"sdm.devices.events.CameraPerson.Person": {
"eventSessionId": EVENT_SESSION_ID,
"eventId": "n:2",
},
"sdm.devices.events.CameraClipPreview.ClipPreview": {
"eventSessionId": EVENT_SESSION_ID,
"previewUrl": "image-url-1",
},
},
timestamp=timestamp2,
)
)
await hass.async_block_till_done()
assert len(events) == 2
assert event_view(events[0].data) == {
"device_id": entry.device_id,
"type": "camera_motion",
"timestamp": timestamp1.replace(microsecond=0),
}
assert event_view(events[1].data) == {
"device_id": entry.device_id,
"type": "camera_person",
"timestamp": timestamp2.replace(microsecond=0),
}
async def test_event_zones(hass, subscriber, setup_platform):
"""Test events published with zone information."""
events = async_capture_events(hass, NEST_EVENT)
await setup_platform()
registry = er.async_get(hass)
entry = registry.async_get("camera.front")
assert entry is not None
event_map = {
"sdm.devices.events.CameraMotion.Motion": {
"eventSessionId": EVENT_SESSION_ID,
"eventId": EVENT_ID,
"zones": ["Zone 1"],
},
}
timestamp = utcnow()
await subscriber.async_receive_event(create_events(event_map, timestamp=timestamp))
await hass.async_block_till_done()
event_time = timestamp.replace(microsecond=0)
assert len(events) == 1
assert event_view(events[0].data) == {
"device_id": entry.device_id,
"type": "camera_motion",
"timestamp": event_time,
"zones": ["Zone 1"],
}
async def test_repeat_var_in_condition(hass, condition):
"""Test repeat action w/ while option."""
event = "test_event"
events = async_capture_events(hass, event)
sequence = {"repeat": {"sequence": {"event": event}}}
if condition == "while":
sequence["repeat"]["while"] = {
"condition": "template",
"value_template": "{{ repeat.index <= 2 }}",
}
else:
sequence["repeat"]["until"] = {
"condition": "template",
"value_template": "{{ repeat.index == 2 }}",
}
script_obj = script.Script(hass, cv.SCRIPT_SCHEMA(sequence))
with mock.patch(
"homeassistant.helpers.condition._LOGGER.error",
side_effect=AssertionError("Template Error"),
):
await script_obj.async_run()
assert len(events) == 2
async def test_camera_multiple_event(hass, subscriber, setup_platform):
"""Test a pubsub message for a camera person event."""
events = async_capture_events(hass, NEST_EVENT)
await setup_platform()
registry = er.async_get(hass)
entry = registry.async_get("camera.front")
assert entry is not None
event_map = {
"sdm.devices.events.CameraMotion.Motion": {
"eventSessionId": EVENT_SESSION_ID,
"eventId": EVENT_ID,
},
"sdm.devices.events.CameraPerson.Person": {
"eventSessionId": EVENT_SESSION_ID,
"eventId": EVENT_ID,
},
}
timestamp = utcnow()
await subscriber.async_receive_event(create_events(event_map, timestamp=timestamp))
await hass.async_block_till_done()
event_time = timestamp.replace(microsecond=0)
assert len(events) == 2
assert event_view(events[0].data) == {
"device_id": entry.device_id,
"type": "camera_motion",
"timestamp": event_time,
}
assert event_view(events[1].data) == {
"device_id": entry.device_id,
"type": "camera_person",
"timestamp": event_time,
}
async def test_doorbell_chime_event(hass):
"""Test a pubsub message for a doorbell event."""
events = async_capture_events(hass, NEST_EVENT)
subscriber = await async_setup_devices(
hass,
"sdm.devices.types.DOORBELL",
create_device_traits("sdm.devices.traits.DoorbellChime"),
)
registry = er.async_get(hass)
entry = registry.async_get("camera.front")
assert entry is not None
assert entry.unique_id == "some-device-id-camera"
assert entry.original_name == "Front"
assert entry.domain == "camera"
device_registry = dr.async_get(hass)
device = device_registry.async_get(entry.device_id)
assert device.name == "Front"
assert device.model == "Doorbell"
assert device.identifiers == {("nest", DEVICE_ID)}
timestamp = utcnow()
await subscriber.async_receive_event(
create_event("sdm.devices.events.DoorbellChime.Chime", timestamp=timestamp)
)
await hass.async_block_till_done()
event_time = timestamp.replace(microsecond=0)
assert len(events) == 1
assert events[0].data == {
"device_id": entry.device_id,
"type": "doorbell_chime",
"timestamp": event_time,
}
async def test_config_local_sdk(hass, hass_client):
"""Test the local SDK."""
command_events = async_capture_events(hass, EVENT_COMMAND_RECEIVED)
turn_on_calls = async_mock_service(hass, "light", "turn_on")
hass.states.async_set("light.ceiling_lights", "off")
assert await async_setup_component(hass, "webhook", {})
config = MockConfig(
hass=hass,
local_sdk_webhook_id="mock-webhook-id",
local_sdk_user_id="mock-user-id",
)
client = await hass_client()
config.async_enable_local_sdk()
resp = await client.post(
"/api/webhook/mock-webhook-id",
json={
"inputs": [
{
"context": {"locale_country": "US", "locale_language": "en"},
"intent": "action.devices.EXECUTE",
"payload": {
"commands": [
{
"devices": [{"id": "light.ceiling_lights"}],
"execution": [
{
"command": "action.devices.commands.OnOff",
"params": {"on": True},
}
],
}
],
"structureData": {},
},
}
],
"requestId": "mock-req-id",
},
)
assert resp.status == 200
result = await resp.json()
assert result["requestId"] == "mock-req-id"
assert len(command_events) == 1
assert command_events[0].context.user_id == config.local_sdk_user_id
assert len(turn_on_calls) == 1
assert turn_on_calls[0].context is command_events[0].context
config.async_disable_local_sdk()
# Webhook is no longer active
resp = await client.post("/api/webhook/mock-webhook-id")
assert resp.status == 200
assert await resp.read() == b""
async def test_camera_person_event(hass):
"""Test a pubsub message for a camera person event."""
events = async_capture_events(hass, NEST_EVENT)
subscriber = await async_setup_devices(
hass,
"sdm.devices.types.DOORBELL",
create_device_traits("sdm.devices.traits.CameraEventImage"),
)
registry = await hass.helpers.entity_registry.async_get_registry()
entry = registry.async_get("camera.front")
assert entry is not None
timestamp = utcnow()
await subscriber.async_receive_event(
create_event("sdm.devices.events.CameraPerson.Person",
timestamp=timestamp))
await hass.async_block_till_done()
event_time = timestamp.replace(microsecond=0)
assert len(events) == 1
assert events[0].data == {
"device_id": entry.device_id,
"type": "camera_person",
"timestamp": event_time,
}
async def test_cover_remote(hass, zha_device_joined_restored,
zigpy_cover_remote):
"""Test zha cover remote."""
# load up cover domain
await zha_device_joined_restored(zigpy_cover_remote)
cluster = zigpy_cover_remote.endpoints[1].out_clusters[
closures.WindowCovering.cluster_id]
zha_events = async_capture_events(hass, "zha_event")
# up command
hdr = make_zcl_header(0, global_command=False)
cluster.handle_message(hdr, [])
await hass.async_block_till_done()
assert len(zha_events) == 1
assert zha_events[0].data[ATTR_COMMAND] == "up_open"
# down command
hdr = make_zcl_header(1, global_command=False)
cluster.handle_message(hdr, [])
await hass.async_block_till_done()
assert len(zha_events) == 2
assert zha_events[1].data[ATTR_COMMAND] == "down_close"
async def test_delay_template_complex_invalid(hass, caplog, script_mode):
"""Test the delay with a complex template that fails."""
event = "test_event"
events = async_capture_events(hass, event)
sequence = cv.SCRIPT_SCHEMA([
{
"event": event
},
{
"delay": {
"seconds": "{{ invalid_delay }}"
}
},
{
"delay": {
"seconds": 5
}
},
{
"event": event
},
])
script_obj = script.Script(hass, sequence, script_mode=script_mode)
start_idx = len(caplog.records)
await script_obj.async_run()
await hass.async_block_till_done()
assert any(rec.levelname == "ERROR" and "Error rendering" in rec.message
for rec in caplog.records[start_idx:])
assert not script_obj.is_running
assert len(events) == 1
async def test_cancel_delay(hass, script_mode):
"""Test the cancelling while the delay is present."""
event = "test_event"
events = async_capture_events(hass, event)
sequence = cv.SCRIPT_SCHEMA([{"delay": {"seconds": 5}}, {"event": event}])
script_obj = script.Script(hass, sequence, script_mode=script_mode)
delay_started_flag = async_watch_for_action(script_obj, "delay")
try:
hass.async_create_task(script_obj.async_run())
await asyncio.wait_for(delay_started_flag.wait(), 1)
assert script_obj.is_running
assert len(events) == 0
except (AssertionError, asyncio.TimeoutError):
await script_obj.async_stop()
raise
else:
await script_obj.async_stop()
assert not script_obj.is_running
# Make sure the script is really stopped.
async_fire_time_changed(hass, dt_util.utcnow() + timedelta(seconds=5))
await hass.async_block_till_done()
assert not script_obj.is_running
assert len(events) == 0
async def test_firing_event_template(hass, script_mode):
"""Test the firing of events."""
event = "test_event"
context = Context()
events = async_capture_events(hass, event)
sequence = cv.SCRIPT_SCHEMA({
"event": event,
"event_data_template": {
"dict": {
1: "{{ is_world }}",
2: "{{ is_world }}{{ is_world }}",
3: "{{ is_world }}{{ is_world }}{{ is_world }}",
},
"list": ["{{ is_world }}", "{{ is_world }}{{ is_world }}"],
},
})
script_obj = script.Script(hass, sequence, script_mode=script_mode)
assert script_obj.can_cancel == (script_mode != "legacy")
await script_obj.async_run({"is_world": "yes"}, context=context)
await hass.async_block_till_done()
assert len(events) == 1
assert events[0].context is context
assert events[0].data == {
"dict": {
1: "yes",
2: "yesyes",
3: "yesyesyes"
},
"list": ["yes", "yesyes"],
}
async def test_watchdog(
hass,
create_hdmi_network,
mock_cec_adapter,
adapter_initialized_value,
watchdog_actions,
):
"""Test the watchdog when adapter is down/up."""
adapter_initialized = PropertyMock(return_value=adapter_initialized_value)
events = async_capture_events(hass, EVENT_HDMI_CEC_UNAVAILABLE)
mock_cec_adapter_instance = mock_cec_adapter.return_value
type(mock_cec_adapter_instance).initialized = adapter_initialized
mock_hdmi_network_instance = await create_hdmi_network()
mock_hdmi_network_instance.set_initialized_callback.assert_called_once()
callback = mock_hdmi_network_instance.set_initialized_callback.call_args.args[0]
callback()
async_fire_time_changed(hass, utcnow() + timedelta(seconds=WATCHDOG_INTERVAL))
await hass.async_block_till_done()
adapter_initialized.assert_called_once_with()
assert len(events) == watchdog_actions
assert mock_cec_adapter_instance.init.call_count == watchdog_actions
async def test_choose(hass, var, result):
"""Test choose action."""
event = "test_event"
events = async_capture_events(hass, event)
sequence = cv.SCRIPT_SCHEMA(
{
"choose": [
{
"conditions": {
"condition": "template",
"value_template": "{{ var == 1 }}",
},
"sequence": {"event": event, "event_data": {"choice": "first"}},
},
{
"conditions": {
"condition": "template",
"value_template": "{{ var == 2 }}",
},
"sequence": {"event": event, "event_data": {"choice": "second"}},
},
],
"default": {"event": event, "event_data": {"choice": "default"}},
}
)
script_obj = script.Script(hass, sequence)
await script_obj.async_run(MappingProxyType({"var": var}))
await hass.async_block_till_done()
assert len(events) == 1
assert events[0].data["choice"] == result
async def test_poll_control_cluster_command(hass, poll_control_device):
"""Test poll control channel response to cluster command."""
checkin_mock = AsyncMock()
poll_control_ch = poll_control_device.channels.pools[0].all_channels[
"1:0x0020"]
cluster = poll_control_ch.cluster
events = async_capture_events(hass, "zha_event")
with mock.patch.object(poll_control_ch, "check_in_response", checkin_mock):
tsn = 22
hdr = make_zcl_header(0, global_command=False, tsn=tsn)
assert not events
cluster.handle_message(
hdr,
[mock.sentinel.args, mock.sentinel.args2, mock.sentinel.args3])
await hass.async_block_till_done()
assert checkin_mock.call_count == 1
assert checkin_mock.await_count == 1
assert checkin_mock.await_args[0][0] == tsn
assert len(events) == 1
data = events[0].data
assert data["command"] == "checkin"
assert data["args"][0] is mock.sentinel.args
assert data["args"][1] is mock.sentinel.args2
assert data["args"][2] is mock.sentinel.args3
assert data["unique_id"] == "00:11:22:33:44:55:66:77:1:0x0020"
assert data["device_id"] == poll_control_device.device_id
async def test_structure_update_event(hass):
"""Test a pubsub message for a new device being added."""
events = async_capture_events(hass, NEST_EVENT)
subscriber = await async_setup_devices(
hass,
"sdm.devices.types.DOORBELL",
create_device_traits(["sdm.devices.traits.DoorbellChime"]),
)
# Entity for first device is registered
registry = er.async_get(hass)
assert registry.async_get("camera.front")
new_device = Device.MakeDevice(
{
"name": "device-id-2",
"type": "sdm.devices.types.CAMERA",
"traits": {
"sdm.devices.traits.Info": {
"customName": "Back",
},
"sdm.devices.traits.CameraLiveStream": {},
},
},
auth=None,
)
device_manager = await subscriber.async_get_device_manager()
device_manager.add_device(new_device)
# Entity for new devie has not yet been loaded
assert not registry.async_get("camera.back")
# Send a message that triggers the device to be loaded
message = EventMessage(
{
"eventId": "some-event-id",
"timestamp": utcnow().isoformat(timespec="seconds"),
"relationUpdate": {
"type": "CREATED",
"subject": "enterprise/example/foo",
"object": "enterprise/example/devices/some-device-id2",
},
},
auth=None,
)
with patch(
"homeassistant.helpers.config_entry_oauth2_flow.async_get_config_entry_implementation"
), patch("homeassistant.components.nest.PLATFORMS", [PLATFORM]), patch(
"homeassistant.components.nest.api.GoogleNestSubscriber",
return_value=subscriber,
):
await subscriber.async_receive_event(message)
await hass.async_block_till_done()
# No home assistant events published
assert not events
assert registry.async_get("camera.front")
# Currently need a manual reload to detect the new entity
assert not registry.async_get("camera.back")
async def test_hue_event(hass, mock_bridge_v2, v2_resources_test_data):
"""Test hue button events."""
await mock_bridge_v2.api.load_test_data(v2_resources_test_data)
await setup_platform(hass, mock_bridge_v2, ["binary_sensor", "sensor"])
await async_setup_devices(mock_bridge_v2)
await async_setup_hue_events(mock_bridge_v2)
events = async_capture_events(hass, "hue_event")
# Emit button update event
btn_event = {
"button": {
"last_event": "initial_press"
},
"id": "c658d3d8-a013-4b81-8ac6-78b248537e70",
"metadata": {
"control_id": 1
},
"type": "button",
}
mock_bridge_v2.api.emit_event("update", btn_event)
# wait for the event
await hass.async_block_till_done()
await hass.async_block_till_done()
assert len(events) == 1
assert events[0].data["id"] == "wall_switch_with_2_controls_button"
assert events[0].data["unique_id"] == btn_event["id"]
assert events[0].data["type"] == btn_event["button"]["last_event"]
assert events[0].data["subtype"] == btn_event["metadata"]["control_id"]
async def test_notifications(hass, hank_binary_switch, integration, client):
"""Test notification events."""
# just pick a random node to fake the value notification events
node = hank_binary_switch
events = async_capture_events(hass, "zwave_js_event")
# Publish fake Basic Set value notification
event = Event(
type="notification",
data={
"source": "node",
"event": "notification",
"nodeId": 23,
"notificationLabel": "Keypad lock operation",
"parameters": {
"userId": 1
},
},
)
node.receive_event(event)
# wait for the event
await hass.async_block_till_done()
assert len(events) == 1
assert events[0].data["type"] == "notification"
assert events[0].data["home_id"] == client.driver.controller.home_id
assert events[0].data["node_id"] == 32
assert events[0].data["label"] == "Keypad lock operation"
assert events[0].data["parameters"]["userId"] == 1
async def test_get_panels(hass, hass_ws_client, mock_http_client):
"""Test get_panels command."""
events = async_capture_events(hass, EVENT_PANELS_UPDATED)
resp = await mock_http_client.get("/map")
assert resp.status == HTTP_NOT_FOUND
hass.components.frontend.async_register_built_in_panel(
"map", "Map", "mdi:tooltip-account", require_admin=True)
resp = await mock_http_client.get("/map")
assert resp.status == 200
assert len(events) == 1
client = await hass_ws_client(hass)
await client.send_json({"id": 5, "type": "get_panels"})
msg = await client.receive_json()
assert msg["id"] == 5
assert msg["type"] == TYPE_RESULT
assert msg["success"]
assert msg["result"]["map"]["component_name"] == "map"
assert msg["result"]["map"]["url_path"] == "map"
assert msg["result"]["map"]["icon"] == "mdi:tooltip-account"
assert msg["result"]["map"]["title"] == "Map"
assert msg["result"]["map"]["require_admin"] is True
hass.components.frontend.async_remove_panel("map")
resp = await mock_http_client.get("/map")
assert resp.status == HTTP_NOT_FOUND
assert len(events) == 2
async def test_event(
hass, auth, setup_platform, subscriber, event_trait, expected_model, expected_type
):
"""Test a pubsub message for a doorbell event."""
events = async_capture_events(hass, NEST_EVENT)
await setup_platform()
registry = er.async_get(hass)
entry = registry.async_get("camera.front")
assert entry is not None
assert entry.unique_id == "some-device-id-camera"
assert entry.domain == "camera"
device_registry = dr.async_get(hass)
device = device_registry.async_get(entry.device_id)
assert device.name == "Front"
assert device.model == expected_model
assert device.identifiers == {("nest", DEVICE_ID)}
timestamp = utcnow()
await subscriber.async_receive_event(create_event(event_trait, timestamp=timestamp))
await hass.async_block_till_done()
event_time = timestamp.replace(microsecond=0)
assert len(events) == 1
assert event_view(events[0].data) == {
"device_id": entry.device_id,
"type": expected_type,
"timestamp": event_time,
}
async def test_webhook_person_event(hass, config_entry, netatmo_auth):
"""Test that person events are handled."""
with selected_platforms(["camera"]):
await hass.config_entries.async_setup(config_entry.entry_id)
await hass.async_block_till_done()
test_netatmo_event = async_capture_events(hass, NETATMO_EVENT)
assert not test_netatmo_event
fake_webhook_event = {
"persons": [
{
"id": "91827374-7e04-5298-83ad-a0cb8372dff1",
"face_id": "a1b2c3d4e5",
"face_key": "9876543",
"is_known": True,
"face_url": "https://netatmocameraimage.blob.core.windows.net/production/12345",
}
],
"snapshot_id": "123456789abc",
"snapshot_key": "foobar123",
"snapshot_url": "https://netatmocameraimage.blob.core.windows.net/production/12346",
"event_type": "person",
"camera_id": "12:34:56:00:f1:62",
"device_id": "12:34:56:00:f1:62",
"event_id": "1234567890",
"message": "MYHOME: John Doe has been seen by Indoor Camera ",
"push_type": "NACamera-person",
}
webhook_id = config_entry.data[CONF_WEBHOOK_ID]
await simulate_webhook(hass, webhook_id, fake_webhook_event)
assert test_netatmo_event
async def test_repeat_conditional(hass, condition):
"""Test repeat action w/ while option."""
event = "test_event"
events = async_capture_events(hass, event)
count = 3
sequence = {
"repeat": {
"sequence": [
{
"event": event,
"event_data_template": {
"first": "{{ repeat.first }}",
"index": "{{ repeat.index }}",
},
},
{"wait_template": "{{ is_state('sensor.test', 'next') }}"},
{"wait_template": "{{ not is_state('sensor.test', 'next') }}"},
],
}
}
if condition == "while":
sequence["repeat"]["while"] = {
"condition": "template",
"value_template": "{{ not is_state('sensor.test', 'done') }}",
}
else:
sequence["repeat"]["until"] = {
"condition": "template",
"value_template": "{{ is_state('sensor.test', 'done') }}",
}
script_obj = script.Script(hass, cv.SCRIPT_SCHEMA(sequence))
wait_started = async_watch_for_action(script_obj, "wait")
hass.states.async_set("sensor.test", "1")
hass.async_create_task(script_obj.async_run())
try:
for index in range(2, count + 1):
await asyncio.wait_for(wait_started.wait(), 1)
wait_started.clear()
hass.states.async_set("sensor.test", "next")
await asyncio.wait_for(wait_started.wait(), 1)
wait_started.clear()
hass.states.async_set("sensor.test", index)
await asyncio.wait_for(wait_started.wait(), 1)
hass.states.async_set("sensor.test", "next")
await asyncio.wait_for(wait_started.wait(), 1)
wait_started.clear()
hass.states.async_set("sensor.test", "done")
await asyncio.wait_for(hass.async_block_till_done(), 1)
except asyncio.TimeoutError:
await script_obj.async_stop()
raise
assert len(events) == count
for index, event in enumerate(events):
assert event.data.get("first") == str(index == 0)
assert event.data.get("index") == str(index + 1)
