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