def test_handle_on_off_manual(self, test_device):
with mock.patch.object(IM.Signal, 'emit') as mocked:
flags = Msg.Flags(Msg.Flags.Type.ALL_LINK_BROADCAST, False)
group = IM.Address(0x00, 0x00, 0x01)
addr = IM.Address(0x01, 0x02, 0x03)
msg = Msg.InpStandard(addr, group, flags,
Msg.CmdType.START_MANUAL_CHANGE, 0x00)
test_device.handle_broadcast(msg)
assert mocked.call_count == 2
calls = [
call(test_device, IM.on_off.Manual.DOWN),
call(test_device, False, IM.on_off.Mode.MANUAL, 'device')
]
mocked.assert_has_calls(calls)
with mock.patch.object(IM.Signal, 'emit') as mocked:
flags = Msg.Flags(Msg.Flags.Type.ALL_LINK_BROADCAST, False)
group = IM.Address(0x00, 0x00, 0x01)
addr = IM.Address(0x01, 0x02, 0x03)
msg = Msg.InpStandard(addr, group, flags,
Msg.CmdType.START_MANUAL_CHANGE, 0x01)
test_device.handle_broadcast(msg)
assert mocked.call_count == 2
calls = [
call(test_device, IM.on_off.Manual.UP),
call(test_device, True, IM.on_off.Mode.MANUAL, 'device')
]
mocked.assert_has_calls(calls)
def test_handle_set_msb(self):
# tests handle_set_msb and get_next_lsb
protocol = MockProto()
modem = MockModem()
addr = IM.Address(0x01, 0x02, 0x03)
device = IM.device.Base(protocol, modem, addr)
# Create the new entry at the current last memory location.
db_flags = Msg.DbFlags(in_use=True,
is_controller=True,
is_last_rec=False)
i1_entry = IM.db.DeviceEntry(addr,
0x01,
device.db.last.mem_loc,
db_flags,
None,
db=device.db)
manager = IM.db.DeviceModifyManagerI1(device, device.db, i1_entry)
# Test bad MSB, should cause resend of set msb
flags = Msg.Flags(Msg.Flags.Type.DIRECT_ACK, False)
msg = Msg.InpStandard(device.addr, device.addr, flags, 0x28, 0x0E)
db_msg = Msg.OutStandard.direct(device.addr, 0x28, 0x0F)
manager.handle_set_msb(msg, None)
assert protocol.msgs[0].to_bytes() == db_msg.to_bytes()
# Test receive correct msb
flags = Msg.Flags(Msg.Flags.Type.DIRECT_ACK, False)
msg = Msg.InpStandard(device.addr, device.addr, flags, 0x28, 0x0F)
db_msg = Msg.OutStandard.direct(device.addr, 0x2B, 0xF8)
manager.handle_set_msb(msg, None)
assert protocol.msgs[1].to_bytes() == db_msg.to_bytes()
def test_finish_write(self):
# tests the finished entry in advance_lsb
protocol = MockProto()
modem = MockModem()
addr = IM.Address(0x01, 0x02, 0x03)
device = IM.device.Base(protocol, modem, addr)
calls = []
def callback(success, msg, data):
calls.append(msg)
# Create the new entry at the current last memory location.
db_flags = Msg.DbFlags(in_use=False,
is_controller=True,
is_last_rec=False)
i1_entry = IM.db.DeviceEntry(addr, 0x01, device.db.last.mem_loc,
db_flags, None)
manager = IM.db.DeviceModifyManagerI1(device, device.db, i1_entry)
# Test received unused from start
flags = Msg.Flags(Msg.Flags.Type.DIRECT_ACK, False)
msg = Msg.InpStandard(device.addr, device.addr, flags, 0x2B, 0x62)
manager.handle_lsb_response(msg, callback)
assert calls[0] == "Database entry written"
# Test received the last byte
manager.record_index = 7
flags = Msg.Flags(Msg.Flags.Type.DIRECT_ACK, False)
msg = Msg.InpStandard(device.addr, device.addr, flags, 0x29, 0x00)
manager.handle_lsb_response(msg, callback)
assert calls[1] == "Database entry written"
def test_handle_manual_not_load(self, test_device):
test_device._load_group = 1
with mock.patch.object(IM.Signal, 'emit') as mocked:
flags = Msg.Flags(Msg.Flags.Type.ALL_LINK_BROADCAST, False)
group = IM.Address(0x00, 0x00, 0x02)
addr = IM.Address(0x01, 0x02, 0x03)
msg = Msg.InpStandard(addr, group, flags,
Msg.CmdType.START_MANUAL_CHANGE, 0x00)
test_device.handle_broadcast(msg)
calls = [
call(test_device, manual=IM.on_off.Manual.DOWN, button=2,
reason='device')
]
assert mocked.call_count == 1
mocked.assert_has_calls(calls, any_order=True)
with mock.patch.object(IM.Signal, 'emit') as mocked:
flags = Msg.Flags(Msg.Flags.Type.ALL_LINK_BROADCAST, False)
group = IM.Address(0x00, 0x00, 0x02)
addr = IM.Address(0x01, 0x02, 0x03)
msg = Msg.InpStandard(addr, group, flags,
Msg.CmdType.START_MANUAL_CHANGE, 0x01)
test_device.handle_broadcast(msg)
calls = [
call(test_device, manual=IM.on_off.Manual.UP, button=2,
reason='device')
]
assert mocked.call_count == 1
mocked.assert_has_calls(calls, any_order=True)
def test_handle_lsb_response(self):
# tests handle_lsb_response and write_lsb_byte
protocol = MockProto()
modem = MockModem()
addr = IM.Address(0x01, 0x02, 0x03)
device = IM.device.Base(protocol, modem, addr)
# Create the new entry at the current last memory location.
db_flags = Msg.DbFlags(in_use=True,
is_controller=True,
is_last_rec=False)
i1_entry = IM.db.DeviceEntry(addr,
0x01,
device.db.last.mem_loc,
db_flags,
None,
db=device.db)
manager = IM.db.DeviceModifyManagerI1(device, device.db, i1_entry)
# Test wrong LSB, should cause poke of set lsb
flags = Msg.Flags(Msg.Flags.Type.DIRECT_ACK, False)
msg = Msg.InpStandard(device.addr, device.addr, flags, 0x2B, 0xA2)
db_msg = Msg.OutStandard.direct(device.addr, 0x29, 0xE2)
manager.handle_lsb_response(msg, None)
assert protocol.msgs[0].to_bytes() == db_msg.to_bytes()
# Test receive correct lsb, should cause request for next lsb
flags = Msg.Flags(Msg.Flags.Type.DIRECT_ACK, False)
msg = Msg.InpStandard(device.addr, device.addr, flags, 0x29, 0xE2)
db_msg = Msg.OutStandard.direct(device.addr, 0x2B, 0xF9)
manager.handle_lsb_response(msg, None)
assert protocol.msgs[1].to_bytes() == db_msg.to_bytes()
def test_cmd_from_msg(self):
# Tests matching the command from the outbound message.
proto = MockProto()
calls = []
def callback(msg, on_done=None):
calls.append(msg)
addr = IM.Address('0a.12.34')
# sent message, match input command
out = Msg.OutStandard.direct(addr, 0x11, 0xff)
handler = IM.handler.StandardCmd(out, callback)
r = handler.msg_received(proto, "dummy")
assert r == Msg.UNKNOWN
# ack back.
out.is_ack = False
r = handler.msg_received(proto, out)
assert r == Msg.CONTINUE
# wrong cmd
out.cmd1 = 0x13
r = handler.msg_received(proto, out)
assert r == Msg.UNKNOWN
# wrong addr
out.cmd1 = 0x11
out.to_addr = IM.Address('0a.12.33')
r = handler.msg_received(proto, out)
assert r == Msg.UNKNOWN
# direct Pre NAK
flags = Msg.Flags(Msg.Flags.Type.DIRECT_NAK, False)
msg = Msg.InpStandard(addr, addr, flags, 0x11, 0xFC)
r = handler.msg_received(proto, msg)
assert r == Msg.CONTINUE
# Now pass in the input message.
# expected input meesage
flags = Msg.Flags(Msg.Flags.Type.DIRECT_ACK, False)
msg = Msg.InpStandard(addr, addr, flags, 0x11, 0x01)
r = handler.msg_received(proto, msg)
assert r == Msg.FINISHED
assert len(calls) == 1
assert calls[0] == msg
# wrong cmd
msg.cmd1 = 0x13
r = handler.msg_received(proto, msg)
assert r == Msg.UNKNOWN
# wrong addr
msg.cmd1 = 0x11
msg.from_addr = IM.Address('0a.12.33')
r = handler.msg_received(proto, msg)
assert r == Msg.UNKNOWN
def test_eq(self):
msg1 = Msg.Flags(Msg.Flags.Type.BROADCAST, False)
msg2 = Msg.Flags(Msg.Flags.Type.BROADCAST, False, 2, 3)
assert msg1 == msg2
msg3 = Msg.Flags(Msg.Flags.Type.BROADCAST, False, 3, 2)
assert msg1 == msg3
msg4 = Msg.Flags(Msg.Flags.Type.BROADCAST, True)
assert msg1 != msg4
msg5 = Msg.Flags(Msg.Flags.Type.DIRECT, False)
assert msg1 != msg5
def test_set_on_level(self, test_device):
# set_on_level(self, level, on_done=None)
assert(test_device.get_on_level() == 255)
def level_bytes(level):
data = bytes([
0x01,
0x06,
level,
] + [0x00] * 11)
return data
for params in ([1, 0x01], [127, 127], [255, 0xFF]):
test_device.set_on_level(on_level=params[0])
assert len(test_device.protocol.sent) == 1
assert test_device.protocol.sent[0].msg.cmd1 == 0x2e
assert (test_device.protocol.sent[0].msg.data ==
level_bytes(params[1]))
test_device.protocol.clear()
test_device.set_on_level(on_level=64)
# Fake having completed the set_on_level(64) request
flags = IM.message.Flags(IM.message.Flags.Type.DIRECT_ACK, False)
ack = IM.message.InpStandard(test_device.addr.hex,
test_device.modem.addr.hex,
flags, 0x2e, 0x00)
test_device.handle_on_level(ack, IM.util.make_callback(None), 64)
assert(test_device.get_on_level() == 64)
test_device.protocol.clear()
# Try multiple button presses in a row; confirm that level goes to
# default on-level then to full brightness, as expected.
# Fast-on should always go to full brightness.
params = [
(Msg.CmdType.ON, 0x00, {"level":64, "mode":IM.on_off.Mode.NORMAL, "is_on": True, "reason":'device', "button":1}),
(Msg.CmdType.ON, 0x00, {"level":255, "mode":IM.on_off.Mode.NORMAL, "is_on": True, "reason":'device', "button":1}),
(Msg.CmdType.ON, 0x00, {"level":64, "mode":IM.on_off.Mode.NORMAL, "is_on": True, "reason":'device', "button":1}),
(Msg.CmdType.OFF, 0x00, {"level":0, "mode":IM.on_off.Mode.NORMAL, "is_on": False, "reason":'device', "button":1}),
(Msg.CmdType.ON_FAST, 0x00, {"level":255, "mode":IM.on_off.Mode.FAST, "is_on": True, "reason":'device', "button":1}),
(Msg.CmdType.ON_FAST, 0x00, {"level":255, "mode":IM.on_off.Mode.FAST, "is_on": True, "reason":'device', "button":1}),
(Msg.CmdType.OFF_FAST, 0x00, {"level":0, "mode":IM.on_off.Mode.FAST, "is_on": False, "reason":'device', "button":1}),
(Msg.CmdType.ON_INSTANT, 0x00,
{"level":64, "mode":IM.on_off.Mode.INSTANT, "is_on": True, "reason":'device', "button":1}),
(Msg.CmdType.ON_INSTANT, 0x00,
{"level":255, "mode":IM.on_off.Mode.INSTANT, "is_on": True, "reason":'device', "button":1}),
(Msg.CmdType.ON_INSTANT, 0x00,
{"level":64, "mode":IM.on_off.Mode.INSTANT, "is_on": True, "reason":'device', "button":1})]
for cmd1, cmd2, expected in params:
with mock.patch.object(IM.Signal, 'emit') as mocked:
print("Trying:", "[%x, %x]" % (cmd1, cmd2))
flags = Msg.Flags(Msg.Flags.Type.ALL_LINK_BROADCAST, False)
group_num = 0x01
group = IM.Address(0x00, 0x00, group_num)
addr = IM.Address(0x01, 0x02, 0x03)
msg = Msg.InpStandard(addr, group, flags, cmd1, cmd2)
test_device.handle_broadcast(msg)
if expected is not None:
mocked.assert_called_once_with(test_device, **expected)
else:
mocked.assert_not_called()
def test_recs(self):
proto = None
calls = []
addr = IM.Address('0a.12.34')
handler = IM.handler.DeviceGetDb(addr, calls.append)
flags = Msg.Flags(Msg.Flags.Type.DIRECT, True)
data = bytes([0x01, 0, 0, 0, 0, 0, 0, 0x01, 0, 0, 0, 0, 0, 0])
msg = Msg.InpExtended(addr, addr, flags, 0x2f, 0x00, data)
r = handler.msg_received(proto, msg)
assert r == Msg.CONTINUE
assert len(calls) == 1
assert calls[0] == msg
msg.data = bytes(14)
r = handler.msg_received(proto, msg)
assert r == Msg.FINISHED
assert len(calls) == 2
assert calls[1] is None
# no match
msg.cmd1 = 0x00
r = handler.msg_received(proto, msg)
assert r == Msg.UNKNOWN
def test_recs(self):
proto = None
calls = []
def callback(success, msg, value):
calls.append(msg)
addr = IM.Address('0a.12.34')
db = Mockdb(addr)
handler = IM.handler.DeviceDbGet(db, callback)
flags = Msg.Flags(Msg.Flags.Type.DIRECT, True)
data = bytes([0x01, 0, 0, 0, 0, 0xFF, 0, 0x01, 0, 0, 0, 0, 0, 0])
msg = Msg.InpExtended(addr, addr, flags, 0x2f, 0x00, data)
r = handler.msg_received(proto, msg)
assert r == Msg.CONTINUE
assert len(calls) == 0
msg.data = bytes(14)
r = handler.msg_received(proto, msg)
assert r == Msg.FINISHED
assert len(calls) == 1
assert calls[0] == "Database received"
# no match
msg.cmd1 = 0x00
r = handler.msg_received(proto, msg)
assert r == Msg.UNKNOWN
def test_plm_sent_ack(self, tmpdir):
proto = MockProto()
modem = MockModem(tmpdir)
calls = []
addr = IM.Address('0a.12.34')
device = IM.device.Base(proto, modem, addr)
def callback(success, msg, data):
calls.append(msg)
# test PLM_sent flag
out = Msg.OutStandard.direct(addr, 0x0D, 0x00)
handler = IM.handler.StandardCmd(out, device.handle_engine, callback)
flags = Msg.Flags(Msg.Flags.Type.DIRECT_ACK, False)
msg = Msg.InpStandard(addr, addr, flags, 0x0D, 0x00)
r = handler.msg_received(proto, msg)
assert r == Msg.UNKNOWN
assert not handler._PLM_sent
# Signal Sent
handler.sending_message(out)
assert handler._PLM_sent
# test PLM nak
r = handler.msg_received(proto, out)
assert r == Msg.CONTINUE
assert not handler._PLM_ACK
# test PLM ack
out.is_ack = True
r = handler.msg_received(proto, out)
assert r == Msg.CONTINUE
assert handler._PLM_ACK
def test_engine_version(self, tmpdir):
# Tests response to get engine version
proto = MockProto()
modem = MockModem(tmpdir)
calls = []
addr = IM.Address('0a.12.34')
device = IM.device.Base(proto, modem, addr)
def callback(success, msg, data):
calls.append(msg)
# i1 test
out = Msg.OutStandard.direct(addr, 0x0D, 0x00)
handler = IM.handler.StandardCmd(out, device.handle_engine, callback)
flags = Msg.Flags(Msg.Flags.Type.DIRECT_ACK, False)
msg = Msg.InpStandard(addr, addr, flags, 0x0D, 0x00)
handler._PLM_sent = True
handler._PLM_ACK = True
r = handler.msg_received(proto, msg)
assert r == Msg.FINISHED
assert calls[0] == "Operation complete"
assert device.db.engine == 0
#i2
msg = Msg.InpStandard(addr, addr, flags, 0x0D, 0x01)
r = handler.msg_received(proto, msg)
assert device.db.engine == 1
#i2cs
msg = Msg.InpStandard(addr, addr, flags, 0x0D, 0x02)
r = handler.msg_received(proto, msg)
assert device.db.engine == 2
def test_handle_ext_flags(self, test_device):
# Captured data from my own motion detector
# 00 01 03 00 ff 0e 00 ff 0e 01 18 4f 00 d2
# set as a 2842 model
test_device.db.set_info(0x10, 0x01, 0x00)
modem_addr = IM.Address(0x01, 0xAA, 0xFF)
flags = Msg.Flags(Msg.Flags.Type.DIRECT, True)
msg = Msg.InpExtended(
test_device.addr, modem_addr, flags, 0x2e, 0x00,
bytes([
0x00, 0x01, 0x03, 0x00, 0xff, 0x0e, 0x00, 0xff, 0x0e, 0x01,
0x18, 0x4f, 0x00, 0xd2
]))
def on_done(success, *args):
assert success
with mock.patch.object(IM.Signal, 'emit') as mocked:
test_device.handle_ext_flags(msg, on_done)
assert test_device.led_on
assert test_device.night_only
assert test_device.on_only
assert test_device.battery_voltage_time > 0
assert mocked.call_count == 1
# the emit call should be false
assert not mocked.call_args.args[1]
def test_input_cmd(self):
# Tests matching the command passed in.
proto = MockProto()
calls = []
def callback(msg, on_done=None):
calls.append(msg)
addr = IM.Address('0a.12.34')
# sent message, match input command
out = Msg.OutStandard.direct(addr, 0x11, 0xff)
handler = IM.handler.StandardCmd(out, callback)
handler._PLM_sent = True
handler._PLM_ACK = True
# right cmd
r = handler.msg_received(proto, out)
assert r == Msg.CONTINUE
# wrong cmd
out.cmd1 = 0x13
r = handler.msg_received(proto, out)
assert r == Msg.UNKNOWN
# Now pass in the input message.
# expected input meesage
flags = Msg.Flags(Msg.Flags.Type.DIRECT_ACK, False)
msg = Msg.InpStandard(addr, addr, flags, 0x11, 0x01)
r = handler.msg_received(proto, msg)
assert r == Msg.FINISHED
assert len(calls) == 1
assert calls[0] == msg
def test_broadcast(self, test_device, caplog):
# test broadcast Messages, Base doesn't handle any
flags = Msg.Flags(Msg.Flags.Type.ALL_LINK_BROADCAST, False)
group = IM.Address(0x00, 0x00, 0x01)
addr = IM.Address(0x01, 0x02, 0x03)
msg = Msg.InpStandard(addr, group, flags, 0x11, 0x00)
test_device.handle_broadcast(msg)
assert "has no handler for broadcast" in caplog.text
def test_handle_refresh_state(self, test_device):
# handle_refresh_state(self, msg, on_done):
def on_done(success, *args):
assert success == True
msg = Msg.OutStandard(IM.Address(12,14,15),
Msg.Flags(Msg.Flags.Type.DIRECT_ACK, False),
0x2e, 0x00, is_ack=True)
test_device.handle_refresh_state(msg, on_done)
def test_hops(self):
obj = Msg.Flags(Msg.Flags.Type.DIRECT, False, 2, 3)
assert obj.hops_left == 2
assert obj.max_hops == 3
obj.set_hops(1)
assert obj.hops_left == 1
assert obj.max_hops == 1
def test_handle_refresh_wet(self, test_device):
with mock.patch.object(test_device, '_set_is_wet') as mocked:
flags = Msg.Flags(Msg.Flags.Type.ALL_LINK_BROADCAST, False)
group = IM.Address(0x00, 0x00, 0x04)
addr = IM.Address(0x01, 0x02, 0x03)
msg = Msg.InpStandard(addr, group, flags, Msg.CmdType.OFF, 0x11)
test_device.handle_refresh(msg)
mocked.assert_called_once_with(True)
def test_acks(self, tmpdir):
proto = MockProto()
calls = []
modem = IM.Modem(proto)
modem.save_path = str(tmpdir)
addr = IM.Address('0a.12.34')
handler = IM.handler.Broadcast(modem)
r = handler.msg_received(proto, "dummy")
assert r == Msg.UNKNOWN
flags = Msg.Flags(Msg.Flags.Type.ALL_LINK_BROADCAST, False)
msg = Msg.InpStandard(addr, addr, flags, 0x11, 0x01)
# no device
r = handler.msg_received(proto, msg)
assert r == Msg.UNKNOWN
device = IM.device.Base(proto, modem, addr, "foo")
device.handle_broadcast = calls.append
modem.add(device)
r = handler.msg_received(proto, msg)
assert r == Msg.CONTINUE
assert len(calls) == 1
# cleanup should be ignored since prev was processed.
flags = Msg.Flags(Msg.Flags.Type.ALL_LINK_CLEANUP, False)
msg = Msg.InpStandard(addr, addr, flags, 0x11, 0x01)
r = handler.msg_received(proto, msg)
assert r == Msg.CONTINUE
assert len(calls) == 1
# If broadcast wasn't found, cleanup should be handled.
handler._handled = False
r = handler.msg_received(proto, msg)
assert r == Msg.CONTINUE
assert len(calls) == 2
flags = Msg.Flags(Msg.Flags.Type.DIRECT_ACK, False)
msg = Msg.InpStandard(addr, addr, flags, 0x11, 0x01)
r = handler.msg_received(proto, msg)
assert r == Msg.UNKNOWN
def test_device_sent_ack(self):
# Tests matching the command from the outbound message.
proto = MockProto()
calls = []
def callback(msg, on_done=None):
calls.append(msg)
addr = IM.Address('0a.12.34')
# sent message, match input command
out = Msg.OutStandard.direct(addr, 0x10, 0x00)
handler = IM.handler.BroadcastCmdResponse(out, callback)
# Signal Sent
handler.sending_message(out)
assert handler._PLM_sent
# test ack sent
out.is_ack = True
r = handler.msg_received(proto, out)
assert r == Msg.CONTINUE
assert handler._PLM_ACK
# test broadcast before device ack
flags = Msg.Flags(Msg.Flags.Type.BROADCAST, False)
msg = Msg.InpStandard(addr, addr, flags, 0x01, 0x00)
r = handler.msg_received(proto, msg)
assert r == Msg.UNKNOWN
assert len(calls) == 0
# mock a device ack
# expected input meesage
flags = Msg.Flags(Msg.Flags.Type.DIRECT_ACK, False)
msg = Msg.InpStandard(addr, addr, flags, 0x10, 0x00)
r = handler.msg_received(proto, msg)
assert r == Msg.CONTINUE
# test a broadcast after device ack
flags = Msg.Flags(Msg.Flags.Type.BROADCAST, False)
msg = Msg.InpStandard(addr, addr, flags, 0x01, 0x00)
r = handler.msg_received(proto, msg)
assert r == Msg.FINISHED
assert len(calls) == 1
assert calls[0] == msg
def test_handle_broadcast(self, test_device, group_num, cmd1, cmd2,
expected, kwargs):
with mock.patch.object(IM.Signal, 'emit') as mocked:
self._is_wet = False
flags = Msg.Flags(Msg.Flags.Type.ALL_LINK_BROADCAST, False)
group = IM.Address(0x00, 0x00, group_num)
addr = IM.Address(0x01, 0x02, 0x03)
msg = Msg.InpStandard(addr, group, flags, cmd1, cmd2)
test_device.handle_broadcast(msg)
mocked.assert_called_once_with(test_device, *expected, **kwargs)
def test_handle_on_off(self, test_device, group, cmd1, cmd2, expected):
with mock.patch.object(IM.Signal, 'emit') as mocked:
flags = Msg.Flags(Msg.Flags.Type.ALL_LINK_BROADCAST, False)
group = IM.Address(0x00, 0x00, group)
addr = IM.Address(0x01, 0x02, 0x03)
msg = Msg.InpStandard(addr, group, flags, cmd1, cmd2)
test_device.handle_broadcast(msg)
if expected is not None:
mocked.assert_called_once_with(test_device, **expected)
else:
mocked.assert_not_called()
def test_broadcast_1(self, test_device, cmd1, expected):
with mock.patch.object(Device.BatterySensor, '_set_state') as mocked:
flags = Msg.Flags(Msg.Flags.Type.ALL_LINK_BROADCAST, False)
group = IM.Address(0x00, 0x00, 0x01)
addr = IM.Address(0x01, 0x02, 0x03)
msg = Msg.InpStandard(addr, group, flags, cmd1, 0x00)
test_device.handle_broadcast(msg)
if expected is not None:
mocked.assert_called_once_with(**expected)
else:
mocked.assert_not_called()
def test_handle_ext_flags(self, test_device):
from_addr = IM.Address(0x01, 0x02, 0x05)
flags = Msg.Flags(Msg.Flags.Type.DIRECT, True)
data = bytes([0x01, 0x01, 0x00, 0x00, 0x20, 0x20, 0x1c, 0x1c, 0x1f,
0x00, 0x01, 0x00, 0x00, 0x00])
msg = Msg.InpExtended(from_addr, test_device.addr, flags,
Msg.CmdType.EXTENDED_SET_GET, 0x00, data)
def on_done(success, *args):
assert success
test_device.handle_ext_flags(msg, on_done)
assert test_device.get_on_level() == 0x1C
def test_handle_manual(self, test_device8):
with mock.patch.object(IM.Signal, 'emit') as mocked:
flags = Msg.Flags(Msg.Flags.Type.ALL_LINK_BROADCAST, False)
group = IM.Address(0x00, 0x00, 0x01)
addr = IM.Address(0x01, 0x02, 0x03)
msg = Msg.InpStandard(addr, group, flags,
Msg.CmdType.START_MANUAL_CHANGE, 0x00)
test_device8.handle_broadcast(msg)
calls = [
call(test_device8,
manual=IM.on_off.Manual.DOWN,
button=1,
reason='device'),
call(test_device8,
button=1,
is_on=False,
level=None,
reason='device',
mode=IM.on_off.Mode.MANUAL)
]
mocked.assert_has_calls(calls, any_order=True)
with mock.patch.object(IM.Signal, 'emit') as mocked:
flags = Msg.Flags(Msg.Flags.Type.ALL_LINK_BROADCAST, False)
group = IM.Address(0x00, 0x00, 0x01)
addr = IM.Address(0x01, 0x02, 0x03)
msg = Msg.InpStandard(addr, group, flags,
Msg.CmdType.START_MANUAL_CHANGE, 0x01)
test_device8.handle_broadcast(msg)
calls = [
call(test_device8,
manual=IM.on_off.Manual.UP,
button=1,
reason='device'),
call(test_device8,
button=1,
is_on=True,
level=None,
reason='device',
mode=IM.on_off.Mode.MANUAL)
]
mocked.assert_has_calls(calls, any_order=True)
def test_handle_model_bad_resp(self, test_device, caplog):
def on_done(success, msg, data):
assert not success
assert "Operation failed" in msg
flags = Msg.Flags(Msg.Flags.Type.BROADCAST, False)
to_addr = IM.Address(0x01, 0x30, 0x45)
from_addr = IM.Address(0x01, 0x02, 0x03)
msg = Msg.InpStandard(from_addr, to_addr, flags, 0x05, 0x00)
with caplog.at_level(logging.DEBUG):
test_device.handle_model(msg, on_done=on_done)
assert 'get_model response with wrong cmd' in caplog.text
def test_handle_heartbeat(self, test_device):
# tests updating the wet/dry state when heartbeat received
with mock.patch.object(IM.Signal, 'emit') as mocked:
self._is_wet = False
flags = Msg.Flags(Msg.Flags.Type.ALL_LINK_BROADCAST, False)
group = IM.Address(0x00, 0x00, 0x04)
addr = IM.Address(0x01, 0x02, 0x03)
msg = Msg.InpStandard(addr, group, flags, Msg.CmdType.OFF, 0x00)
test_device.handle_broadcast(msg)
assert mocked.call_count == 2
calls = [call(test_device, True), call(test_device, True)]
mocked.assert_has_calls(calls)
def test_handle_set_msb(self):
# tests handle_set_msb
device = MockDevice()
device_db = IM.db.Device(IM.Address(0x01, 0x02, 0x03))
manager = IM.db.DeviceScanManagerI1(device, device_db)
on_done = None
manager.msb = 0x0F
# Test bad MSB, should cause resend of set msb
flags = Msg.Flags(Msg.Flags.Type.DIRECT_ACK, False)
msg = Msg.InpStandard(device_db.addr, device_db.addr, flags, 0x28, 0x0E)
db_msg = Msg.OutStandard.direct(device_db.addr, 0x28, 0x0F)
manager.handle_set_msb(msg, on_done)
assert device.msgs[0].to_bytes() == db_msg.to_bytes()
# Test receive correct msb
flags = Msg.Flags(Msg.Flags.Type.DIRECT_ACK, False)
msg = Msg.InpStandard(device_db.addr, device_db.addr, flags, 0x28, 0x0F)
db_msg = Msg.OutStandard.direct(device_db.addr, 0x2B, 0xF8)
manager.handle_set_msb(msg, on_done)
assert device.msgs[1].to_bytes() == db_msg.to_bytes()
def test_nak_str(self):
from_addr = IM.Address(0x01, 0x02, 0x03)
to_addr = IM.Address(0x03, 0x05, 0x07)
# ID not in DB error
flags = Msg.Flags(Msg.Flags.Type.DIRECT_NAK, False)
obj = Msg.InpStandard(from_addr, to_addr, flags, 0x00, 0xFF)
nak_str = obj.nak_str()
assert len(nak_str) > 0
# unknow error type
flags = Msg.Flags(Msg.Flags.Type.DIRECT_NAK, False)
obj = Msg.InpStandard(from_addr, to_addr, flags, 0x00, 0x10)
nak_str = obj.nak_str()
assert len(nak_str) == 0
# not a nak
flags = Msg.Flags(Msg.Flags.Type.DIRECT_ACK, False)
obj = Msg.InpStandard(from_addr, to_addr, flags, 0x00, 0xFF)
nak_str = obj.nak_str()
assert len(nak_str) == 0
def test_handle_model(self, test_device, caplog):
def on_done(success, msg, data):
assert success
assert msg == "Operation complete"
flags = Msg.Flags(Msg.Flags.Type.BROADCAST, False)
to_addr = IM.Address(0x01, 0x30, 0x45)
from_addr = IM.Address(0x01, 0x02, 0x03)
msg = Msg.InpStandard(from_addr, to_addr, flags, 0x01, 0x00)
with caplog.at_level(logging.DEBUG):
test_device.handle_model(msg, on_done=on_done)
assert 'received model information' in caplog.text
assert '2476D' in test_device.db.desc.model
