def test_plm_ack_sent(test_db, test_entry_dev1_ctrl, test_entry_dev1_resp):
# delete 2nd entry and then re-add the first
test_db.add_entry(test_entry_dev1_ctrl)
test_db.add_entry(test_entry_dev1_resp)
assert len(test_db) == 2
handler = Handler.ModemDbModify(test_db, test_entry_dev1_ctrl)
db_flags = Msg.DbFlags(in_use=True,
is_controller=test_entry_dev1_ctrl.is_controller,
is_last_rec=False)
msg = Msg.OutAllLinkUpdate(Msg.OutAllLinkUpdate.Cmd.DELETE,
db_flags,
test_entry_dev1_ctrl.group,
test_entry_dev1_ctrl.addr,
data=None)
# Add update to delete 2nd entry
handler.add_update(msg, test_entry_dev1_resp)
# Then restore the first
db_flags = Msg.DbFlags(in_use=True,
is_controller=test_entry_dev1_ctrl.is_controller,
is_last_rec=False)
msg2 = Msg.OutAllLinkUpdate(Msg.OutAllLinkUpdate.Cmd.ADD_CONTROLLER,
db_flags, test_entry_dev1_ctrl.group,
test_entry_dev1_ctrl.addr,
test_entry_dev1_ctrl.data)
handler.add_update(msg2, test_entry_dev1_ctrl)
# try prior to sent
msg.is_ack = True
ret = handler.msg_received(test_db.device.protocol, msg)
assert ret == Msg.UNKNOWN
assert not handler._PLM_sent
# Signal Sent
handler.sending_message(msg)
assert handler._PLM_sent
# signal first delete ack
msg.is_ack = True
handler.msg_received(test_db.device.protocol, msg)
assert len(test_db) == 1
# signal second delete ack prior to sent
ret = handler.msg_received(test_db.device.protocol, msg)
assert ret == Msg.UNKNOWN
# Signal Sent
handler.sending_message(msg)
assert handler._PLM_sent
# signal second delete ack
handler.msg_received(test_db.device.protocol, msg)
assert len(test_db) == 0
# signal final add ack
# Signal Sent
handler.sending_message(msg)
assert handler._PLM_sent
msg2.is_ack = True
handler.msg_received(test_db.device.protocol, msg2)
assert len(test_db) == 1
assert test_db.entries[0] == test_entry_dev1_ctrl
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_delete_post_two_second(self, test_device, test_entry_dev1_ctrl,
test_entry_dev1_resp, caplog):
# add_on_device(self, entry, on_done=None)
# test deleting the second of two entries
test_device.add_entry(test_entry_dev1_ctrl)
test_device.add_entry(test_entry_dev1_resp)
test_device._delete_on_device_post_search(test_entry_dev1_resp)
assert (test_device.device.protocol.sent[0].msg.cmd ==
Msg.OutAllLinkUpdate.Cmd.DELETE)
db_flags = Msg.DbFlags.from_bytes(bytes(1))
sent = test_device.device.protocol.sent[0]
assert (sent.msg.to_bytes() == Msg.OutAllLinkUpdate(
Msg.OutAllLinkUpdate.Cmd.DELETE,
db_flags, test_entry_dev1_resp.group, test_entry_dev1_resp.addr,
bytes(3)).to_bytes())
assert len(sent.handler.next) == 2
assert (sent.handler.next[0][0].to_bytes() == Msg.OutAllLinkUpdate(
Msg.OutAllLinkUpdate.Cmd.DELETE,
db_flags, test_entry_dev1_resp.group, test_entry_dev1_resp.addr,
bytes(3)).to_bytes())
db_flags = Msg.DbFlags(
in_use=True,
is_controller=test_entry_dev1_ctrl.is_controller,
is_last_rec=False)
assert (sent.handler.next[1][0].to_bytes() == Msg.OutAllLinkUpdate(
Msg.OutAllLinkUpdate.Cmd.ADD_CONTROLLER, db_flags,
test_entry_dev1_ctrl.group, test_entry_dev1_ctrl.addr,
test_entry_dev1_ctrl.data).to_bytes())
def test_recs_not_used(self, caplog):
calls = []
def callback(success, msg, done):
calls.append(msg)
db = Mockdb()
db.device = MockDevice()
handler = IM.handler.ModemDbGet(db, callback)
handler._PLM_sent = True
handler._PLM_ACK = True
proto = MockProtocol()
flags = Msg.DbFlags(False, True, False).to_bytes()[0]
b = bytes([0x02, 0x57,
flags, # flags
0x01, # group
0x3a, 0x29, 0x84, # addess
0x01, 0x0e, 0x43]) # data
msg = Msg.InpAllLinkRec.from_bytes(b)
r = handler.msg_received(proto, msg)
assert r == Msg.FINISHED
assert isinstance(db.device.sent[0]['msg'], Msg.OutAllLinkGetNext)
assert db.device.sent[0]['handler'] == handler
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_handle_write_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)
device.db.delta = 5
msg = "fake message"
on_done = "fake on_done"
with mock.patch.object(manager, 'handle_lsb_response') as mocked:
manager.handle_lsb_write_response(msg, on_done)
assert device.db.delta == 6
mocked.assert_called_once_with(msg, on_done)
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_start_modify_with_on_done(self):
# tests start_modify and _set_msb
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)
db_msg = Msg.OutStandard.direct(device.addr, 0x28, 0x0F)
def fake_on_done(success, msg, data):
pass
manager.start_modify(on_done=fake_on_done)
assert protocol.msgs[0].to_bytes() == db_msg.to_bytes()
assert manager.on_done == fake_on_done
def test_update_nak(self, test_db, test_entry_dev1_ctrl,
test_entry_dev1_ctrl_mod):
test_db.add_entry(test_entry_dev1_ctrl)
assert len(test_db) == 1
handler = Handler.ModemDbModify(test_db,
test_entry_dev1_ctrl_mod,
existing_entry=test_entry_dev1_ctrl)
handler._PLM_sent = True
handler._PLM_ACK = True
db_flags = Msg.DbFlags(
in_use=True,
is_controller=test_entry_dev1_ctrl.is_controller,
is_last_rec=False)
msg = Msg.OutAllLinkUpdate(Msg.OutAllLinkUpdate.Cmd.UPDATE,
db_flags,
test_entry_dev1_ctrl_mod.group,
test_entry_dev1_ctrl_mod.addr,
data=bytes(3),
is_ack=False)
handler.msg_received(test_db.device.protocol, msg)
# entry should still be there, it gets updated on next ack
assert len(test_db) == 1
assert len(test_db.device.protocol.sent) == 1
assert (test_db.device.protocol.sent[0].msg.cmd ==
Msg.OutAllLinkUpdate.Cmd.ADD_CONTROLLER)
assert handler.is_retry
def test_repr(self):
addr = IM.Address('12.34.ab')
ctrl = Msg.DbFlags(in_use=True, is_controller=True, is_last_rec=False)
data = bytes([0x01, 0x02, 0x03])
mem_loc = (0xfe << 8) + 0x10
obj = IM.db.DeviceEntry(addr, 0x03, mem_loc, ctrl, data, db=None)
assert obj.__repr__() == "fe10: 12.34.ab"
def test_entry_3():
addr = IM.Address('56.78.cd')
data = bytes([0xff, 0x00, 0x00])
group = 0x01
in_use = True
is_controller = False
is_last_rec = False
db_flags = Msg.DbFlags(in_use, is_controller, is_last_rec)
mem_loc = 1
return IM.db.DeviceEntry(addr, group, mem_loc, db_flags, data)
def test_add_on_device_empty_resp(self, test_device, test_entry_dev1_resp):
# add_on_device(self, entry, on_done=None)
# test adding a resp to an empty db
assert len(test_device) == 0
test_device.add_on_device(test_entry_dev1_resp)
assert (test_device.device.protocol.sent[0].msg.cmd ==
Msg.OutAllLinkUpdate.Cmd.ADD_RESPONDER)
assert (test_device.device.protocol.sent[0].msg.db_flags.to_bytes() ==
Msg.DbFlags(in_use=True, is_controller=False,
is_last_rec=False).to_bytes())
def test_add_on_device_empty_ctrl(self, test_device, test_entry_dev1_ctrl):
# add_on_device(self, entry, on_done=None)
# test adding to an entry db with ctrl
assert len(test_device) == 0
test_device.add_on_device(test_entry_dev1_ctrl)
assert (test_device.device.protocol.sent[0].msg.cmd ==
Msg.OutAllLinkUpdate.Cmd.ADD_CONTROLLER)
assert (test_device.device.protocol.sent[0].msg.db_flags.to_bytes() ==
Msg.DbFlags(in_use=True, is_controller=True,
is_last_rec=False).to_bytes())
def test_add_on_device_update_resp(self, test_device,
test_entry_dev1_resp):
# add_on_device(self, entry, on_done=None)
# test calling update on an existing entry
test_device.add_entry(test_entry_dev1_resp)
test_device.add_on_device(test_entry_dev1_resp)
assert (test_device.device.protocol.sent[0].msg.cmd ==
Msg.OutAllLinkUpdate.Cmd.UPDATE)
assert (test_device.device.protocol.sent[0].msg.db_flags.to_bytes() ==
Msg.DbFlags(in_use=True, is_controller=False,
is_last_rec=False).to_bytes())
def test_delete_on_device_update_resp(self, test_device,
test_entry_dev1_resp,
test_entry_dev1_ctrl):
# test calling delete
test_device.add_entry(test_entry_dev1_resp)
test_device.add_entry(test_entry_dev1_ctrl)
test_device.delete_on_device(test_entry_dev1_resp)
test_device.delete_on_device(test_entry_dev1_ctrl)
assert (test_device.device.protocol.sent[0].msg.cmd ==
Msg.OutAllLinkUpdate.Cmd.DELETE)
assert (test_device.device.protocol.sent[0].msg.db_flags.to_bytes() ==
Msg.DbFlags(in_use=True, is_controller=False,
is_last_rec=False).to_bytes())
assert (test_device.device.protocol.sent[0].msg.addr ==
test_entry_dev1_resp.addr)
assert (test_device.device.protocol.sent[0].msg.group ==
test_entry_dev1_resp.group)
assert (test_device.device.protocol.sent[1].msg.cmd ==
Msg.OutAllLinkUpdate.Cmd.DELETE)
assert (test_device.device.protocol.sent[1].msg.db_flags.to_bytes() ==
Msg.DbFlags(in_use=True, is_controller=True,
is_last_rec=False).to_bytes())
def test_ctrl(self):
addr = IM.Address('12.34.ab')
ctrl = Msg.DbFlags(in_use=True, is_controller=True, is_last_rec=False)
data = bytes([0x01, 0x02, 0x03])
mem_loc = (0xfe << 8) + 0x10
obj = IM.db.DeviceEntry(addr, 0x03, mem_loc, ctrl, data, db=None)
assert obj.addr == addr
assert obj.group == 0x03
assert obj.db_flags.in_use == ctrl.in_use
assert obj.db_flags.is_controller == ctrl.is_controller
assert obj.db_flags.is_last_rec == ctrl.is_last_rec
assert obj.mem_loc == mem_loc
assert obj.data == data
assert obj.mem_bytes() == bytes([0xfe, 0x10])
d = obj.to_json()
obj2 = IM.db.DeviceEntry.from_json(d, db=None)
assert obj2.addr == obj.addr
assert obj2.group == obj.group
assert obj2.mem_loc == obj.mem_loc
assert obj2.db_flags.in_use == obj.db_flags.in_use
assert obj2.db_flags.is_controller == obj.db_flags.is_controller
assert obj2.db_flags.is_last_rec == obj.db_flags.is_last_rec
assert obj2.data == obj.data
assert obj == obj2
data = bytes([0x00, 0x01,
0xfe, 0x10, # mem_loc
0x00, ctrl.to_bytes()[0], 0x03,
addr.ids[0], addr.ids[1], addr.ids[2],
data[0], data[1], data[2]])
obj3 = IM.db.DeviceEntry.from_bytes(data, db=None)
assert obj3.addr == obj.addr
assert obj3.group == obj.group
assert obj3.mem_loc == obj.mem_loc
assert obj3.db_flags.in_use == obj.db_flags.in_use
assert obj3.db_flags.is_controller == obj.db_flags.is_controller
assert obj3.db_flags.is_last_rec == obj.db_flags.is_last_rec
assert obj3.data == obj.data
assert obj == obj3
obj3.group = 0xff
assert obj != obj3
assert obj < obj3
obj.addr = IM.Address('12.34.ac')
assert obj3 < obj
str(obj)
def test_nack(self, test_db, test_entry_dev1_ctrl):
handler = Handler.ModemDbSearch(test_db)
db_flags = Msg.DbFlags(
in_use=True,
is_controller=test_entry_dev1_ctrl.is_controller,
is_last_rec=False)
msg = Msg.OutAllLinkUpdate(Msg.OutAllLinkUpdate.Cmd.EXISTS,
db_flags,
test_entry_dev1_ctrl.group,
test_entry_dev1_ctrl.addr,
data=None,
is_ack=False)
ret = handler.msg_received(test_db.device.protocol, msg)
assert ret == Msg.FINISHED
def test_delete(self, test_db, test_entry_dev1_ctrl):
# delete, no next
test_db.add_entry(test_entry_dev1_ctrl)
assert len(test_db) == 1
handler = Handler.ModemDbModify(test_db, test_entry_dev1_ctrl)
db_flags = Msg.DbFlags(
in_use=True,
is_controller=test_entry_dev1_ctrl.is_controller,
is_last_rec=False)
msg = Msg.OutAllLinkUpdate(Msg.OutAllLinkUpdate.Cmd.DELETE,
db_flags,
test_entry_dev1_ctrl.group,
test_entry_dev1_ctrl.addr,
data=None,
is_ack=True)
handler.msg_received(test_db.device.protocol, msg)
assert len(test_db) == 0
def test_add(self, test_db, test_entry_dev1_ctrl):
# add clean
assert len(test_db) == 0
handler = Handler.ModemDbModify(test_db, test_entry_dev1_ctrl)
db_flags = Msg.DbFlags(
in_use=True,
is_controller=test_entry_dev1_ctrl.is_controller,
is_last_rec=False)
msg = Msg.OutAllLinkUpdate(Msg.OutAllLinkUpdate.Cmd.ADD_CONTROLLER,
db_flags,
test_entry_dev1_ctrl.group,
test_entry_dev1_ctrl.addr,
data=bytes(3),
is_ack=True)
handler.msg_received(test_db.device.protocol, msg)
assert len(test_db) == 1
assert test_db.entries[0] == test_entry_dev1_ctrl
def test_prevent_loop(self, test_db, test_entry_dev1_ctrl, caplog):
handler = Handler.ModemDbModify(test_db,
test_entry_dev1_ctrl_mod,
existing_entry=test_entry_dev1_ctrl)
handler.is_retry = True
db_flags = Msg.DbFlags(
in_use=True,
is_controller=test_entry_dev1_ctrl.is_controller,
is_last_rec=False)
msg = Msg.OutAllLinkUpdate(Msg.OutAllLinkUpdate.Cmd.UPDATE,
db_flags,
test_entry_dev1_ctrl.group,
test_entry_dev1_ctrl.addr,
data=bytes(3),
is_ack=False)
handler.msg_received(test_db.device.protocol, msg)
# This should fail to prevent infinite loops
assert "db update failed" in caplog.text
def test_i1(self):
addr = IM.Address('20.c4.ba')
ctrl = Msg.DbFlags(in_use=True, is_controller=True, is_last_rec=False)
mem_loc = (0x0F << 8) + 0xFF
data = bytes([0xFE, 0x1F, 0x00])
entry = IM.db.DeviceEntry.from_i1_bytes(bytes(
[0x0F, 0xFF, 0xE2, 0x01, 0x20, 0xC4, 0xBA, 0xFE, 0x1F, 0x00]),
db=None)
assert entry.addr == addr
assert entry.group == 0x01
assert entry.db_flags.in_use == ctrl.in_use
assert entry.db_flags.is_controller == ctrl.is_controller
assert entry.db_flags.is_last_rec == ctrl.is_last_rec
assert entry.mem_loc == mem_loc
assert entry.data == data
str(entry)
def test_entry_received(self, test_db, test_entry_dev1_ctrl):
handler = Handler.ModemDbSearch(test_db)
db_flags = Msg.DbFlags(
in_use=True,
is_controller=test_entry_dev1_ctrl.is_controller,
is_last_rec=False)
msg = Msg.InpAllLinkRec(db_flags, test_entry_dev1_ctrl.group,
test_entry_dev1_ctrl.addr,
test_entry_dev1_ctrl.data)
ret = handler.msg_received(test_db.device.protocol, msg)
assert ret == Msg.FINISHED
assert len(test_db) == 1
assert test_db.entries[0] == test_entry_dev1_ctrl
sent = test_db.device.protocol.sent
assert len(sent) == 1
assert sent[0].msg.cmd == Msg.OutAllLinkUpdate.Cmd.SEARCH
assert sent[0].msg.group == test_entry_dev1_ctrl.group
assert sent[0].msg.addr == test_entry_dev1_ctrl.addr
def test_entry_not_used(self, test_db, test_entry_dev1_ctrl):
# I don't think this is possible, but we have the code, so test for it
handler = Handler.ModemDbSearch(test_db)
db_flags = Msg.DbFlags(
in_use=False,
is_controller=test_entry_dev1_ctrl.is_controller,
is_last_rec=False)
msg = Msg.InpAllLinkRec(db_flags, test_entry_dev1_ctrl.group,
test_entry_dev1_ctrl.addr,
test_entry_dev1_ctrl.data)
ret = handler.msg_received(test_db.device.protocol, msg)
assert ret == Msg.FINISHED
assert len(test_db) == 0
sent = test_db.device.protocol.sent
assert len(sent) == 1
assert sent[0].msg.cmd == Msg.OutAllLinkUpdate.Cmd.SEARCH
assert sent[0].msg.group == test_entry_dev1_ctrl.group
assert sent[0].msg.addr == test_entry_dev1_ctrl.addr
def test_label(self):
addr = IM.Address('12.34.ab')
ctrl = Msg.DbFlags(in_use=True, is_controller=True, is_last_rec=False)
data = bytes([0x01, 0x02, 0x03])
mem_loc = (0xfe << 8) + 0x10
obj = IM.db.DeviceEntry(addr, 0x03, mem_loc, ctrl, data, db=None)
assert obj.label == str(addr)
protocol = MockProto()
modem = MockModem()
addr1 = IM.Address(0x03, 0x04, 0x05)
addr = IM.Address('12.34.ab')
device1 = IM.device.Base(protocol, modem, addr1)
obj = IM.db.DeviceEntry(addr, 0x03, mem_loc, ctrl, data, db=device1.db)
device = IM.device.Base(protocol, modem, addr, name="Awesomesauce")
modem.set_linked_device(device)
assert obj.label == "12.34.ab (Awesomesauce)"
def test_add_nak(self, test_db, test_entry_dev1_ctrl):
assert len(test_db) == 0
handler = Handler.ModemDbModify(test_db, test_entry_dev1_ctrl)
db_flags = Msg.DbFlags(
in_use=True,
is_controller=test_entry_dev1_ctrl.is_controller,
is_last_rec=False)
msg = Msg.OutAllLinkUpdate(Msg.OutAllLinkUpdate.Cmd.ADD_CONTROLLER,
db_flags,
test_entry_dev1_ctrl.group,
test_entry_dev1_ctrl.addr,
data=bytes(3),
is_ack=False)
handler.msg_received(test_db.device.protocol, msg)
# entry should be added
assert len(test_db) == 1
assert len(test_db.device.protocol.sent) == 1
assert (test_db.device.protocol.sent[0].msg.cmd ==
Msg.OutAllLinkUpdate.Cmd.UPDATE)
assert handler.is_retry
def test_delete_nak(self, test_db, test_entry_dev1_ctrl, caplog):
# delete, no next
test_db.add_entry(test_entry_dev1_ctrl)
assert len(test_db) == 1
handler = Handler.ModemDbModify(test_db, test_entry_dev1_ctrl)
handler._PLM_sent = True
handler._PLM_ACK = True
db_flags = Msg.DbFlags(
in_use=True,
is_controller=test_entry_dev1_ctrl.is_controller,
is_last_rec=False)
msg = Msg.OutAllLinkUpdate(Msg.OutAllLinkUpdate.Cmd.DELETE,
db_flags,
test_entry_dev1_ctrl.group,
test_entry_dev1_ctrl.addr,
data=None,
is_ack=False)
handler.msg_received(test_db.device.protocol, msg)
assert len(test_db) == 1
assert "db update failed" in caplog.text
def test_update(self, test_db, test_entry_dev1_ctrl,
test_entry_dev1_ctrl_mod):
# update clean
test_db.add_entry(test_entry_dev1_ctrl)
assert len(test_db) == 1
handler = Handler.ModemDbModify(test_db,
test_entry_dev1_ctrl_mod,
existing_entry=test_entry_dev1_ctrl)
db_flags = Msg.DbFlags(
in_use=True,
is_controller=test_entry_dev1_ctrl.is_controller,
is_last_rec=False)
msg = Msg.OutAllLinkUpdate(Msg.OutAllLinkUpdate.Cmd.UPDATE,
db_flags,
test_entry_dev1_ctrl.group,
test_entry_dev1_ctrl.addr,
data=bytes(3),
is_ack=True)
handler.msg_received(test_db.device.protocol, msg)
assert len(test_db) == 1
assert test_db.entries[0].data == test_entry_dev1_ctrl_mod.data
def test_plm_sent(self, test_db, tmpdir):
db_flags = Msg.DbFlags(in_use=True,
is_controller=False,
is_last_rec=False)
handler = Handler.ModemDbSearch(test_db)
assert not handler._PLM_sent
#Try a message prior to sent
msg = Msg.OutAllLinkUpdate(Msg.OutAllLinkUpdate.Cmd.EXISTS,
db_flags,
0x01,
0x01,
data=None,
is_ack=True)
ret = handler.msg_received(test_db.device.protocol, msg)
assert ret == Msg.UNKNOWN
# Signal Sent
handler.sending_message(msg)
assert handler._PLM_sent
#Try a message after sent
ret = handler.msg_received(test_db.device.protocol, msg)
assert ret == Msg.CONTINUE
def test_basic(self):
obj = IM.db.Device()
assert len(obj) == 0
assert obj.is_current(0) is False
obj.delta = 1
assert obj.is_current(1) is True
obj.clear_delta()
assert obj.is_current(1) is False
addr = IM.Address(0x10, 0xab, 0x1c)
flags = Msg.Flags(Msg.Flags.Type.DIRECT, True)
db_flags = Msg.DbFlags(in_use=True, is_controller=True,
last_record=False)
data = bytes([0x01, 0x02, 0x03])
raw = [0x00, 0x01,
0xfe, 0x10, # mem_loc
0x00, db_flags.to_bytes()[0],
0x03, # group
addr.ids[0], addr.ids[1], addr.ids[2],
data[0], data[1], data[2], 0x06]
msg = Msg.InpExtended(addr, addr, flags, 0x00, 0x00, bytes(raw))
obj.handle_db_rec(msg)
# add same addr w/ different group
raw[6] = 0x02
msg.data = raw
obj.handle_db_rec(msg)
# new addr, same group
addr2 = IM.Address(0x10, 0xab, 0x1d)
raw[9] = 0x1d
msg.data = raw
obj.handle_db_rec(msg)
# responder - not in a group
db_flags = Msg.DbFlags(in_use=True, is_controller=False,
last_record=False)
raw[5] = db_flags.to_bytes()[0]
msg.data = raw
obj.handle_db_rec(msg)
# in use = False
db_flags = Msg.DbFlags(in_use=False, is_controller=True,
last_record=False)
raw[5] = db_flags.to_bytes()[0]
msg.data = raw
obj.handle_db_rec(msg)
assert len(obj.entries) == 4
assert len(obj.unused) == 1
assert len(obj.groups) == 2
grp = obj.find_group(0x02)
assert len(grp) == 2
assert grp[0].addr == addr
assert grp[1].addr == addr2
e = obj.find(addr, 0x02, 'CTRL')
assert e.addr == addr
assert e.group == 0x02
assert e.db_flags.is_controller is True
e = obj.find(addr2, 0x02, 'RESP')
assert e.addr == addr2
assert e.group == 0x02
assert e.db_flags.is_responder is True
e = obj.find(addr, 0x05, 'RESP')
assert e is None
str(obj)
j = obj.to_json()
obj2 = IM.db.Device.from_json(j)
assert len(obj2.entries) == 4
assert len(obj2.unused) == 1
assert len(obj2.groups) == 2
obj2.clear()
assert len(obj2) == 0
assert len(obj2.entries) == 0
assert len(obj2.unused) == 0
assert len(obj2.groups) == 0
def test_basic(self):
obj = IM.db.Device(IM.Address(0x01, 0x02, 0x03))
assert len(obj) == 0
assert obj.is_current(0) is False
obj.delta = 1
assert obj.is_current(1) is True
obj.set_delta(None)
assert obj.is_current(1) is False
assert obj.engine is None
obj.set_engine(1)
assert obj.engine == 1
assert obj.desc is None
assert obj.firmware is None
obj.set_info(1, 2, 3)
assert obj.desc.dev_cat == 1
assert obj.desc.sub_cat == 2
assert obj.firmware == 3
addr = IM.Address(0x10, 0xab, 0x1c)
flags = Msg.Flags(Msg.Flags.Type.DIRECT, True)
db_flags = Msg.DbFlags(in_use=True, is_controller=True,
is_last_rec=False)
data = bytes([0x01, 0x02, 0x03])
raw = [0x00, 0x01,
0xfe, 0x10, # mem_loc
0x00, db_flags.to_bytes()[0],
0x03, # group
addr.ids[0], addr.ids[1], addr.ids[2],
data[0], data[1], data[2], 0x06]
msg = Msg.InpExtended(addr, addr, flags, 0x00, 0x00, bytes(raw))
entry = IM.db.DeviceEntry.from_bytes(msg.data)
obj.add_entry(entry)
# add same addr w/ different group
raw[6] = 0x02
raw[3] = 0x11 # have to change memory location
msg.data = raw
entry = IM.db.DeviceEntry.from_bytes(msg.data)
obj.add_entry(entry)
# new addr, same group
addr2 = IM.Address(0x10, 0xab, 0x1d)
raw[9] = 0x1d
raw[3] = 0x12 # have to change memory location
msg.data = raw
entry = IM.db.DeviceEntry.from_bytes(msg.data)
obj.add_entry(entry)
# responder - not in a group
db_flags = Msg.DbFlags(in_use=True, is_controller=False,
is_last_rec=False)
raw[5] = db_flags.to_bytes()[0]
raw[3] = 0x13 # have to change memory location
msg.data = raw
entry = IM.db.DeviceEntry.from_bytes(msg.data)
obj.add_entry(entry)
# in use = False
db_flags = Msg.DbFlags(in_use=False, is_controller=True,
is_last_rec=False)
raw[5] = db_flags.to_bytes()[0]
raw[3] = 0x14 # have to change memory location
msg.data = raw
entry = IM.db.DeviceEntry.from_bytes(msg.data)
obj.add_entry(entry)
assert len(obj.entries) == 4
assert len(obj.unused) == 1
assert len(obj.groups) == 2
grp = obj.find_group(0x02)
assert len(grp) == 2
assert grp[0].addr == addr
assert grp[1].addr == addr2
e = obj.find(addr, 0x02, True)
assert e.addr == addr
assert e.group == 0x02
assert e.db_flags.is_controller is True
e = obj.find(addr2, 0x02, False)
assert e.addr == addr2
assert e.group == 0x02
assert e.db_flags.is_controller is False
e = obj.find(addr, 0x05, False)
assert e is None
str(obj)
j = obj.to_json()
obj2 = IM.db.Device.from_json(j, '', None)
assert len(obj2.entries) == 4
assert len(obj2.unused) == 1
assert len(obj2.groups) == 2
obj2.clear()
assert len(obj2) == 0
assert len(obj2.entries) == 0
assert len(obj2.unused) == 0
assert len(obj2.groups) == 0
