def test_rx_device_annce(app, ieee, nwk):
dst_ep = 0
cluster_id = ZDOCmd.Device_annce
device = mock.MagicMock()
device.status = device.Status.NEW
app.get_device = mock.MagicMock(return_value=device)
app.handle_join = mock.MagicMock()
app.handle_message = mock.MagicMock()
data = t.uint8_t(0xAA).serialize()
data += nwk.serialize()
data += ieee.serialize()
data += t.uint8_t(0x8E).serialize()
app.handle_rx(
ieee,
nwk,
mock.sentinel.src_ep,
dst_ep,
cluster_id,
mock.sentinel.profile_id,
mock.sentinel.rx_opt,
data,
)
assert app.handle_message.call_count == 1
assert app.handle_join.call_count == 1
assert app.handle_join.call_args[0][0] == nwk
assert app.handle_join.call_args[0][1] == ieee
assert app.handle_join.call_args[0][2] == 0
async def test_setup_adds_proper_devices(hass):
"""Test if setup adds devices."""
with mock.patch("homeassistant.components.mfi.switch.MFiClient"
) as mock_client, mock.patch(
"homeassistant.components.mfi.switch.MfiSwitch",
side_effect=mfi.MfiSwitch) as mock_switch:
ports = {
i: mock.MagicMock(model=model,
label=f"Port {i}",
output=False,
data={},
ident=f"abcd-{i}")
for i, model in enumerate(mfi.SWITCH_MODELS)
}
ports["bad"] = mock.MagicMock(model="notaswitch")
print(ports["bad"].model)
mock_client.return_value.get_devices.return_value = [
mock.MagicMock(ports=ports)
]
assert await async_setup_component(hass, COMPONENT.DOMAIN, GOOD_CONFIG)
await hass.async_block_till_done()
for ident, port in ports.items():
if ident != "bad":
mock_switch.assert_any_call(port)
assert mock.call(ports["bad"], hass) not in mock_switch.mock_calls
def mock_client_fixture():
"""Mock the prometheus client."""
with mock.patch(f"{PROMETHEUS_PATH}.prometheus_client") as client:
counter_client = mock.MagicMock()
client.Counter = mock.MagicMock(return_value=counter_client)
setattr(counter_client, "labels", mock.MagicMock(return_value=mock.MagicMock()))
yield counter_client
async def _test_remote_at_command(api, monkeypatch, do_reply=True):
monkeypatch.setattr(t, "serialize",
mock.MagicMock(return_value=mock.sentinel.serialize))
def mock_command(name, *args):
rsp = xbee_api.COMMAND_REQUESTS[name][2]
ret = None
if rsp:
ret = asyncio.Future()
if do_reply:
ret.set_result(mock.sentinel.at_result)
return ret
api._command = mock.MagicMock(side_effect=mock_command)
api._seq = mock.sentinel.seq
for at_cmd in xbee_api.AT_COMMANDS:
res = await api._remote_at_command(
mock.sentinel.ieee,
mock.sentinel.nwk,
mock.sentinel.opts,
at_cmd,
mock.sentinel.args,
)
assert t.serialize.call_count == 1
assert api._command.call_count == 1
assert api._command.call_args[0][0] == "remote_at"
assert api._command.call_args[0][1] == mock.sentinel.ieee
assert api._command.call_args[0][2] == mock.sentinel.nwk
assert api._command.call_args[0][3] == mock.sentinel.opts
assert api._command.call_args[0][4] == at_cmd.encode("ascii")
assert api._command.call_args[0][5] == mock.sentinel.serialize
assert res == mock.sentinel.at_result
t.serialize.reset_mock()
api._command.reset_mock()
def _device_join(app, dev, data):
app.handle_message = mock.MagicMock()
app.handle_join = mock.MagicMock()
dst_ep = 0
cluster_id = 0x0013
_test_rx(app, dev, dev.nwk, dst_ep, cluster_id, data)
assert app.handle_join.call_count == 1
assert app.handle_message.call_count == 1
def mock_client_fixture():
"""Mock the pubsub client."""
with mock.patch(f"{GOOGLE_PUBSUB_PATH}.pubsub_v1") as client:
client.PublisherClient = mock.MagicMock()
setattr(
client.PublisherClient,
"from_service_account_json",
mock.MagicMock(return_value=mock.MagicMock()),
)
yield client
def make_event(entity_id):
"""Make a mock event for test."""
domain = split_entity_id(entity_id)[0]
state = mock.MagicMock(
state="not blank",
domain=domain,
entity_id=entity_id,
object_id="entity",
attributes={},
)
return mock.MagicMock(data={"new_state": state}, time_fired=12345)
def test_rx(app):
device = mock.MagicMock()
app.handle_message = mock.MagicMock()
_test_rx(app, device, mock.sentinel.src_nwk, data=mock.sentinel.message)
assert app.handle_message.call_count == 1
assert app.handle_message.call_args == ((
device,
mock.sentinel.profile_id,
mock.sentinel.cluster_id,
mock.sentinel.src_ep,
mock.sentinel.dst_ep,
mock.sentinel.message,
), )
def test_setup_adds_proper_devices(self, mock_sensor, mock_client):
"""Test if setup adds devices."""
ports = {
i: mock.MagicMock(model=model) for i, model in enumerate(mfi.SENSOR_MODELS)
}
ports["bad"] = mock.MagicMock(model="notasensor")
mock_client.return_value.get_devices.return_value = [
mock.MagicMock(ports=ports)
]
assert setup_component(self.hass, sensor.DOMAIN, self.GOOD_CONFIG)
for ident, port in ports.items():
if ident != "bad":
mock_sensor.assert_any_call(port, self.hass)
assert mock.call(ports["bad"], self.hass) not in mock_sensor.mock_calls
async def test_init_api_mode(api, monkeypatch):
monkeypatch.setattr(api._uart, "baudrate", 57600)
api.enter_at_command_mode = mock.AsyncMock(return_value=True)
res = await api.init_api_mode()
assert res is None
assert api.enter_at_command_mode.call_count == 1
api.enter_at_command_mode = mock.AsyncMock(return_value=False)
res = await api.init_api_mode()
assert res is False
assert api.enter_at_command_mode.call_count == 10
async def enter_at_mode():
if api._uart.baudrate == 9600:
return True
return False
api._uart.baudrate = 57600
api.enter_at_command_mode = mock.MagicMock(side_effect=enter_at_mode)
api.api_mode_at_commands = mock.AsyncMock(return_value=True)
res = await api.init_api_mode()
assert res is True
assert api.enter_at_command_mode.call_count == 5
async def test_command_mode_at_cmd_timeout(api):
command = "+++"
api._uart.command_mode_send = mock.MagicMock()
result = await api.command_mode_at_cmd(command)
assert result is None
def test_handle_explicit_rx_indicator(api):
s = mock.sentinel
data = [
s.src_ieee,
s.src_nwk,
s.src_ep,
s.dst_ep,
s.cluster_id,
s.profile,
s.opts,
b"abcdef",
]
api._app = mock.MagicMock()
api._app.handle_rx = mock.MagicMock()
api._handle_explicit_rx_indicator(*data)
assert api._app.handle_rx.call_count == 1
def test_remote_at_cmd(app, device):
dev = device()
app.get_device = mock.MagicMock(return_value=dev)
app._api = mock.MagicMock(spec=XBee)
s = mock.sentinel
app.remote_at_command(s.nwk,
s.cmd,
s.data,
apply_changes=True,
encryption=True)
assert app._api._remote_at_command.call_count == 1
assert app._api._remote_at_command.call_args[0][0] is dev.ieee
assert app._api._remote_at_command.call_args[0][1] == s.nwk
assert app._api._remote_at_command.call_args[0][2] == 0x12
assert app._api._remote_at_command.call_args[0][3] == s.cmd
assert app._api._remote_at_command.call_args[0][4] == s.data
def test_rx_nwk_0000(app):
app._handle_reply = mock.MagicMock()
app.handle_message = mock.MagicMock()
app.get_device = mock.MagicMock()
app.handle_rx(
b"\x01\x02\x03\x04\x05\x06\x07\x08",
0x0000,
mock.sentinel.src_ep,
mock.sentinel.dst_ep,
mock.sentinel.cluster_id,
mock.sentinel.profile_id,
mock.sentinel.rxopts,
b"",
)
assert app.handle_message.call_count == 1
assert app.get_device.call_count == 2
def test_setup_adds_proper_devices(self, mock_switch, mock_client):
"""Test if setup adds devices."""
ports = {
i: mock.MagicMock(model=model)
for i, model in enumerate(mfi.SWITCH_MODELS)
}
ports["bad"] = mock.MagicMock(model="notaswitch")
print(ports["bad"].model)
mock_client.return_value.get_devices.return_value = [
mock.MagicMock(ports=ports)
]
assert setup_component(self.hass, switch.DOMAIN, self.GOOD_CONFIG)
self.hass.block_till_done()
for ident, port in ports.items():
if ident != "bad":
mock_switch.assert_any_call(port)
assert mock.call(ports["bad"], self.hass) not in mock_switch.mock_calls
def light_mock(hass, brightness):
"""Mock light."""
controller_mock = mock.MagicMock()
dev_dict = {
"address": "a1",
"name": "fake_light",
"brightness_levels": brightness
}
return mochad.MochadLight(hass, controller_mock, dev_dict)
def test_frame_received_no_handler(api, monkeypatch):
monkeypatch.setattr(
t, "deserialize",
mock.MagicMock(return_value=(b"deserialized data", b"")))
my_handler = mock.MagicMock()
cmd = "no_handler"
cmd_id = 0x00
xbee_api.COMMAND_RESPONSES[cmd] = (cmd_id, (), None)
api._commands_by_id[cmd_id] = cmd
cmd_opts = xbee_api.COMMAND_RESPONSES[cmd]
cmd_id = cmd_opts[0]
payload = b"\x01\x02\x03\x04"
data = cmd_id.to_bytes(1, "big") + payload
api.frame_received(data)
assert t.deserialize.call_count == 1
assert t.deserialize.call_args[0][0] == payload
assert my_handler.call_count == 0
def test_rx_unknown_device_ieee(app):
"""Unknown NWK, and unknown IEEE."""
app.handle_message = mock.MagicMock()
app.handle_join = mock.MagicMock()
app.get_device = mock.MagicMock(side_effect=KeyError)
app.handle_rx(
b"\xff\xff\xff\xff\xff\xff\xff\xff",
0x3334,
mock.sentinel.src_ep,
mock.sentinel.dst_ep,
mock.sentinel.cluster_id,
mock.sentinel.profile_id,
mock.sentinel.rxopts,
b"",
)
assert app.handle_join.call_count == 0
assert app.get_device.call_count == 2
assert app.handle_message.call_count == 0
def test_handle_remote_at_rsp(api):
api._handle_at_response = mock.MagicMock()
s = mock.sentinel
api._handle_remote_at_response(s.frame_id, s.ieee, s.nwk, s.cmd, s.status,
s.data)
assert api._handle_at_response.call_count == 1
assert api._handle_at_response.call_args[0][0] == s.frame_id
assert api._handle_at_response.call_args[0][1] == s.cmd
assert api._handle_at_response.call_args[0][2] == s.status
assert api._handle_at_response.call_args[0][3] == s.data
def setUp(self):
"""Set up things to be run when tests are started."""
self.hass = get_test_home_assistant()
controller_mock = mock.MagicMock()
dev_dict = {
"address": "a1",
"name": "fake_light",
"brightness_levels": 256
}
self.light = mochad.MochadLight(self.hass, controller_mock, dev_dict)
async def test_form_network(app):
legacy_module = False
async def mock_at_command(cmd, *args):
if cmd == "MY":
return 0x0000
elif cmd == "WR":
app._api.coordinator_started_event.set()
elif cmd == "CE" and legacy_module:
raise RuntimeError
return None
app._api._at_command = mock.MagicMock(spec=XBee._at_command,
side_effect=mock_at_command)
app._api._queued_at = mock.MagicMock(spec=XBee._at_command,
side_effect=mock_at_command)
app._get_association_state = mock.AsyncMock(
spec=application.ControllerApplication._get_association_state,
return_value=0x00,
)
app.write_network_info = mock.MagicMock(wraps=app.write_network_info)
await app.form_network()
assert app._api._at_command.call_count >= 1
assert app._api._queued_at.call_count >= 7
network_info = app.write_network_info.mock_calls[0][2]["network_info"]
app._api._queued_at.assert_any_call("SC", 1 << (network_info.channel - 11))
app._api._queued_at.assert_any_call("KY", b"ZigBeeAlliance09")
app._api._at_command.reset_mock()
app._api._queued_at.reset_mock()
legacy_module = True
await app.form_network()
assert app._api._at_command.call_count >= 1
assert app._api._queued_at.call_count >= 7
network_info = app.write_network_info.mock_calls[0][2]["network_info"]
app._api._queued_at.assert_any_call("SC", 1 << (network_info.channel - 11))
app._api._queued_at.assert_any_call("KY", b"ZigBeeAlliance09")
def test_handle_tx_status_duplicate(api):
status = t.TXStatus.SUCCESS
frame_id = 0x12
send_fut = mock.MagicMock(spec=asyncio.Future)
send_fut.set_result.side_effect = asyncio.InvalidStateError
api._awaiting[frame_id] = (send_fut, )
s = mock.sentinel
api._handle_tx_status(frame_id, s.dst_nwk, s.retries, status, s.disc)
assert len(api._awaiting) == 0
assert send_fut.set_result.call_count == 1
assert send_fut.set_exception.call_count == 0
def _handle_tx_status(api, status, wrong_frame_id=False):
status = t.TXStatus(status)
frame_id = 0x12
send_fut = mock.MagicMock(spec=asyncio.Future)
api._awaiting[frame_id] = (send_fut, )
s = mock.sentinel
if wrong_frame_id:
frame_id += 1
api._handle_tx_status(frame_id, s.dst_nwk, s.retries, status,
t.DiscoveryStatus())
return send_fut
async def test_setup_adds_proper_devices(hass):
"""Test if setup adds devices."""
with mock.patch(
"homeassistant.components.mfi.sensor.MFiClient"
) as mock_client, mock.patch(
"homeassistant.components.mfi.sensor.MfiSensor", side_effect=mfi.MfiSensor
) as mock_sensor:
ports = {
i: mock.MagicMock(model=model) for i, model in enumerate(mfi.SENSOR_MODELS)
}
ports["bad"] = mock.MagicMock(model="notasensor")
mock_client.return_value.get_devices.return_value = [
mock.MagicMock(ports=ports)
]
assert await async_setup_component(hass, COMPONENT.DOMAIN, GOOD_CONFIG)
await hass.async_block_till_done()
for ident, port in ports.items():
if ident != "bad":
mock_sensor.assert_any_call(port, hass)
assert mock.call(ports["bad"], hass) not in mock_sensor.mock_calls
async def _test_start_network(
app,
ai_status=0xFF,
api_mode=True,
api_config_succeeds=True,
ee=1,
eo=2,
zs=2,
legacy_module=False,
):
ai_tries = 5
app.state.node_info.nwk = mock.sentinel.nwk
def _at_command_mock(cmd, *args):
nonlocal ai_tries
if not api_mode:
raise asyncio.TimeoutError
if cmd == "CE" and legacy_module:
raise RuntimeError
ai_tries -= 1 if cmd == "AI" else 0
return {
"AI": ai_status if ai_tries < 0 else 0xFF,
"CE": 1 if ai_status == 0 else 0,
"EO": eo,
"EE": ee,
"ID": 0x25DCF87E03EA5906,
"MY": 0xFFFE if ai_status else 0x0000,
"NJ": mock.sentinel.at_nj,
"OI": 0xDD94,
"OP": mock.sentinel.at_op,
"SH": 0x08070605,
"SL": 0x04030201,
"ZS": zs,
}.get(cmd, None)
def init_api_mode_mock():
nonlocal api_mode
api_mode = api_config_succeeds
return api_config_succeeds
with mock.patch("zigpy_xbee.api.XBee") as XBee_mock:
api_mock = mock.MagicMock()
api_mock._at_command = mock.AsyncMock(side_effect=_at_command_mock)
api_mock.init_api_mode = mock.AsyncMock(side_effect=init_api_mode_mock)
XBee_mock.new = mock.AsyncMock(return_value=api_mock)
await app.connect()
app.form_network = mock.AsyncMock()
await app.load_network_info()
await app.start_network()
return app
def test_rx_unknown_device(app, device):
"""Unknown NWK, but existing device."""
app.handle_message = mock.MagicMock()
app.handle_join = mock.MagicMock()
dev = device(nwk=0x1234)
app.devices[dev.ieee] = dev
num_before_rx = len(app.devices)
app.handle_rx(
b"\x08\x07\x06\x05\x04\x03\x02\x01",
0x3334,
mock.sentinel.src_ep,
mock.sentinel.dst_ep,
mock.sentinel.cluster_id,
mock.sentinel.profile_id,
mock.sentinel.rxopts,
b"",
)
assert app.handle_join.call_count == 1
assert app.handle_message.call_count == 1
assert len(app.devices) == num_before_rx
async def test_command_not_connected(api):
api._uart = None
def mock_api_frame(name, *args):
return mock.sentinel.api_frame_data, api._seq
api._api_frame = mock.MagicMock(side_effect=mock_api_frame)
for cmd, cmd_opts in xbee_api.COMMAND_REQUESTS.items():
with pytest.raises(zigpy.exceptions.APIException):
await api._command(cmd, mock.sentinel.cmd_data)
assert api._api_frame.call_count == 0
api._api_frame.reset_mock()
async def _test_request(app,
expect_reply=True,
send_success=True,
send_timeout=False,
is_end_device=True,
node_desc=True,
**kwargs):
seq = 123
nwk = 0x2345
ieee = t.EUI64(b"\x01\x02\x03\x04\x05\x06\x07\x08")
dev = app.add_device(ieee, nwk)
if node_desc:
dev.node_desc = mock.MagicMock()
dev.node_desc.is_end_device = is_end_device
else:
dev.node_desc = None
def _mock_command(cmdname, ieee, nwk, src_ep, dst_ep, cluster, profile,
radius, options, data):
send_fut = asyncio.Future()
if not send_timeout:
if send_success:
send_fut.set_result(xbee_t.TXStatus.SUCCESS)
else:
send_fut.set_result(xbee_t.TXStatus.ADDRESS_NOT_FOUND)
return send_fut
app._api._command = mock.MagicMock(side_effect=_mock_command)
return await app.request(dev,
0x0260,
1,
2,
3,
seq,
b"\xaa\x55\xbe\xef",
expect_reply=expect_reply,
**kwargs)
async def test_command(api):
def mock_api_frame(name, *args):
c = xbee_api.COMMAND_REQUESTS[name]
return mock.sentinel.api_frame_data, c[2]
api._api_frame = mock.MagicMock(side_effect=mock_api_frame)
api._uart.send = mock.MagicMock()
for cmd_name, cmd_opts in xbee_api.COMMAND_REQUESTS.items():
cmd_id, schema, expect_reply = cmd_opts
ret = api._command(cmd_name, mock.sentinel.cmd_data)
if expect_reply:
assert asyncio.isfuture(ret) is True
ret.cancel()
else:
assert ret is None
assert api._api_frame.call_count == 1
assert api._api_frame.call_args[0][0] == cmd_name
assert api._api_frame.call_args[0][1] == api._seq - 1
assert api._api_frame.call_args[0][2] == mock.sentinel.cmd_data
assert api._uart.send.call_count == 1
assert api._uart.send.call_args[0][0] == mock.sentinel.api_frame_data
api._api_frame.reset_mock()
api._uart.send.reset_mock()
ret = api._command(cmd_name,
mock.sentinel.cmd_data,
mask_frame_id=True)
assert ret is None
assert api._api_frame.call_count == 1
assert api._api_frame.call_args[0][0] == cmd_name
assert api._api_frame.call_args[0][1] == 0
assert api._api_frame.call_args[0][2] == mock.sentinel.cmd_data
assert api._uart.send.call_count == 1
assert api._uart.send.call_args[0][0] == mock.sentinel.api_frame_data
api._api_frame.reset_mock()
api._uart.send.reset_mock()
def test_frame_received(api, monkeypatch):
monkeypatch.setattr(
t,
"deserialize",
mock.MagicMock(return_value=(
[
mock.sentinel.arg_0,
mock.sentinel.arg_1,
mock.sentinel.arg_2,
mock.sentinel.arg_3,
mock.sentinel.arg_4,
mock.sentinel.arg_5,
mock.sentinel.arg_6,
mock.sentinel.arg_7,
mock.sentinel.arg_8,
],
b"",
)),
)
my_handler = mock.MagicMock()
for cmd, cmd_opts in xbee_api.COMMAND_RESPONSES.items():
cmd_id = cmd_opts[0]
payload = b"\x01\x02\x03\x04"
data = cmd_id.to_bytes(1, "big") + payload
setattr(api, "_handle_{}".format(cmd), my_handler)
api.frame_received(data)
assert t.deserialize.call_count == 1
assert t.deserialize.call_args[0][0] == payload
assert my_handler.call_count == 1
assert my_handler.call_args[0][0] == mock.sentinel.arg_0
assert my_handler.call_args[0][1] == mock.sentinel.arg_1
assert my_handler.call_args[0][2] == mock.sentinel.arg_2
assert my_handler.call_args[0][3] == mock.sentinel.arg_3
t.deserialize.reset_mock()
my_handler.reset_mock()
