jmg
/
alarmdecoder
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
A clone of: https://github.com/nutechsoftware/alarmdecoder This is requires as they dropped support for older firmware releases w/o building in backward compatibility code, and they had previously hardcoded pyserial to a python2 only version.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
408 Commits
2 Branches
2.3 MiB
 
Tree: 59c196919a
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '59c196919a'
${ noResults }
alarmdecoder/test/test_ad2.py

367 lines
16 KiB
Raw Blame History 

  1. import time

  2. 

  3. from builtins import bytes

  4. 

  5. from unittest import TestCase

  6. from mock import Mock, MagicMock, patch

  7. 

  8. from alarmdecoder.decoder import AlarmDecoder

  9. from alarmdecoder.devices import USBDevice

  10. from alarmdecoder.messages import Message, RFMessage, LRRMessage, ExpanderMessage

  11. from alarmdecoder.event.event import Event, EventHandler

  12. from alarmdecoder.zonetracking import Zonetracker

  13. from alarmdecoder.panels import ADEMCO, DSC

  14. from alarmdecoder.messages.lrr import LRR_EVENT_TYPE, LRR_EVENT_STATUS

  15. from alarmdecoder.states import FireState

  16. 

  17. 

  18. class TestAlarmDecoder(TestCase):

  19.     def setUp(self):

  20.         self._panicked = False

  21.         self._relay_changed = False

  22.         self._power_changed = False

  23.         self._chime_changed = False

  24.         self._ready_changed = False

  25.         self._alarmed = False

  26.         self._bypassed = False

  27.         self._battery = False

  28.         self._fire = False

  29.         self._armed = False

  30.         self._got_config = False

  31.         self._message_received = False

  32.         self._rfx_message_received = False

  33.         self._lrr_message_received = False

  34.         self._expander_message_received = False

  35.         self._sending_received_status = None

  36.         self._alarm_restored = False

  37.         self._on_boot_received = False

  38.         self._zone_faulted = None

  39.         self._zone_restored = None

  40. 

  41.         self._device = Mock(spec=USBDevice)

  42.         self._device.on_open = EventHandler(Event(), self._device)

  43.         self._device.on_close = EventHandler(Event(), self._device)

  44.         self._device.on_read = EventHandler(Event(), self._device)

  45.         self._device.on_write = EventHandler(Event(), self._device)

  46. 

  47.         self._decoder = AlarmDecoder(self._device, ignore_lrr_states=False)

  48.         self._decoder.on_panic += self.on_panic

  49.         self._decoder.on_relay_changed += self.on_relay_changed

  50.         self._decoder.on_power_changed += self.on_power_changed

  51.         self._decoder.on_ready_changed += self.on_ready_changed

  52.         self._decoder.on_chime_changed += self.on_chime_changed

  53.         self._decoder.on_alarm += self.on_alarm

  54.         self._decoder.on_alarm_restored += self.on_alarm_restored

  55.         self._decoder.on_bypass += self.on_bypass

  56.         self._decoder.on_low_battery += self.on_battery

  57.         self._decoder.on_fire += self.on_fire

  58.         self._decoder.on_arm += self.on_arm

  59.         self._decoder.on_disarm += self.on_disarm

  60.         self._decoder.on_config_received += self.on_config

  61.         self._decoder.on_message += self.on_message

  62.         self._decoder.on_rfx_message += self.on_rfx_message

  63.         self._decoder.on_lrr_message += self.on_lrr_message

  64.         self._decoder.on_expander_message += self.on_expander_message

  65.         self._decoder.on_sending_received += self.on_sending_received

  66.         self._decoder.on_boot += self.on_boot

  67.         self._decoder.on_zone_fault += self.on_zone_fault

  68.         self._decoder.on_zone_restore += self.on_zone_restore

  69. 

  70.         self._decoder.address_mask = int('ffffffff', 16)

  71.         self._decoder.open()

  72. 

  73.     def tearDown(self):

  74.         pass

  75. 

  76.     ### Library events

  77.     def on_panic(self, sender, *args, **kwargs):

  78.         self._panicked = kwargs['status']

  79. 

  80.     def on_relay_changed(self, sender, *args, **kwargs):

  81.         self._relay_changed = True

  82. 

  83.     def on_power_changed(self, sender, *args, **kwargs):

  84.         self._power_changed = kwargs['status']

  85. 

  86.     def on_ready_changed(self, sender, *args, **kwargs):

  87.         self._ready_changed = kwargs['status']

  88. 

  89.     def on_chime_changed(self, sender, *args, **kwargs):

  90.         self._chime_changed = kwargs['status']

  91. 

  92.     def on_alarm(self, sender, *args, **kwargs):

  93.         self._alarmed = True

  94. 

  95.     def on_alarm_restored(self, sender, *args, **kwargs):

  96.         self._alarm_restored = True

  97. 

  98.     def on_bypass(self, sender, *args, **kwargs):

  99.         self._bypassed = kwargs['status']

  100. 

  101.     def on_battery(self, sender, *args, **kwargs):

  102.         self._battery = kwargs['status']

  103. 

  104.     def on_fire(self, sender, *args, **kwargs):

  105.         self._fire = kwargs['status']

  106. 

  107.     def on_arm(self, sender, *args, **kwargs):

  108.         self._armed = True

  109. 

  110.     def on_disarm(self, sender, *args, **kwargs):

  111.         self._armed = False

  112. 

  113.     def on_config(self, sender, *args, **kwargs):

  114.         self._got_config = True

  115. 

  116.     def on_message(self, sender, *args, **kwargs):

  117.         self._message_received = True

  118. 

  119.     def on_rfx_message(self, sender, *args, **kwargs):

  120.         self._rfx_message_received = True

  121. 

  122.     def on_lrr_message(self, sender, *args, **kwargs):

  123.         self._lrr_message_received = True

  124. 

  125.     def on_expander_message(self, sender, *args, **kwargs):

  126.         self._expander_message_received = True

  127. 

  128.     def on_sending_received(self, sender, *args, **kwargs):

  129.         self._sending_received_status = kwargs['status']

  130. 

  131.     def on_boot(self, sender, *args, **kwargs):

  132.         self._on_boot_received = True

  133. 

  134.     def on_zone_fault(self, sender, *args, **kwargs):

  135.         self._zone_faulted = kwargs['zone']

  136. 

  137.     def on_zone_restore(self, sender, *args, **kwargs):

  138.         self._zone_restored = kwargs['zone']

  139. 

  140.     ### Tests

  141.     def test_open(self):

  142.         self._decoder.open()

  143.         self._device.open.assert_called()

  144. 

  145.     def test_close(self):

  146.         self._decoder.open()

  147. 

  148.         self._decoder.close()

  149.         self._device.close.assert_called()

  150. 

  151.     def test_send(self):

  152.         self._decoder.send('test')

  153.         self._device.write.assert_called_with(b'test')

  154. 

  155.     def test_get_config(self):

  156.         self._decoder.get_config()

  157.         self._device.write.assert_called_with(b"C\r")

  158. 

  159.     def test_save_config(self):

  160.         self._decoder.save_config()

  161.         self._device.write.assert_called()

  162. 

  163.     def test_reboot(self):

  164.         self._decoder.reboot()

  165.         self._device.write.assert_called_with(b'=')

  166. 

  167.     def test_fault(self):

  168.         self._decoder.fault_zone(1)

  169.         self._device.write.assert_called_with(bytes("L{0:02}{1}\r".format(1, 1), 'utf-8'))

  170. 

  171.     def test_fault_wireproblem(self):

  172.         self._decoder.fault_zone(1, simulate_wire_problem=True)

  173.         self._device.write.assert_called_with(bytes("L{0:02}{1}\r".format(1, 2), 'utf-8'))

  174. 

  175.     def test_clear_zone(self):

  176.         self._decoder.clear_zone(1)

  177.         self._device.write.assert_called_with(bytes("L{0:02}0\r".format(1), 'utf-8'))

  178. 

  179.     def test_message(self):

  180.         msg = self._decoder._handle_message(b'[0000000000000000----],000,[f707000600e5800c0c020000],"                                "')

  181.         self.assertIsInstance(msg, Message)

  182. 

  183.         self._decoder._on_read(self, data=b'[0000000000000000----],000,[f707000600e5800c0c020000],"                                "')

  184.         self.assertTrue(self._message_received)

  185. 

  186.     def test_message_kpm(self):

  187.         msg = self._decoder._handle_message(b'!KPM:[0000000000000000----],000,[f707000600e5800c0c020000],"                                "')

  188.         self.assertIsInstance(msg, Message)

  189. 

  190.         self._decoder._on_read(self, data=b'[0000000000000000----],000,[f707000600e5800c0c020000],"                                "')

  191.         self.assertTrue(self._message_received)

  192. 

  193.     def test_expander_message(self):

  194.         msg = self._decoder._handle_message(b'!EXP:07,01,01')

  195.         self.assertIsInstance(msg, ExpanderMessage)

  196. 

  197.         self._decoder._on_read(self, data=b'!EXP:07,01,01')

  198.         self.assertTrue(self._expander_message_received)

  199. 

  200.     def test_relay_message(self):

  201.         msg = self._decoder._handle_message(b'!REL:12,01,01')

  202.         self.assertIsInstance(msg, ExpanderMessage)

  203.         self.assertTrue(self._relay_changed)

  204. 

  205.     def test_rfx_message(self):

  206.         msg = self._decoder._handle_message(b'!RFX:0180036,80')

  207.         self.assertIsInstance(msg, RFMessage)

  208.         self.assertTrue(self._rfx_message_received)

  209. 

  210.     def test_panic_v1(self):

  211.         # LRR v1

  212.         msg = self._decoder._handle_message(b'!LRR:012,1,ALARM_PANIC')

  213.         self.assertIsInstance(msg, LRRMessage)

  214.         self.assertTrue(self._panicked)

  215. 

  216.         msg = self._decoder._handle_message(b'!LRR:012,1,CANCEL')

  217.         self.assertIsInstance(msg, LRRMessage)

  218.         self.assertFalse(self._panicked)

  219. 

  220.     def test_panic_v2(self):

  221.         # LRR v2

  222.         msg = self._decoder._handle_message(b'!LRR:099,1,CID_1123,ff') # Panic

  223.         self.assertIsInstance(msg, LRRMessage)

  224.         self.assertTrue(self._panicked)

  225. 

  226.         msg = self._decoder._handle_message(b'!LRR:001,1,CID_1406,ff') # Cancel

  227.         self.assertIsInstance(msg, LRRMessage)

  228.         self.assertFalse(self._panicked)

  229. 

  230.     def test_config_message(self):

  231.         msg = self._decoder._handle_message(b'!CONFIG>MODE=A&CONFIGBITS=ff04&ADDRESS=18&LRR=N&COM=N&EXP=NNNNN&REL=NNNN&MASK=ffffffff&DEDUPLICATE=N')

  232.         self.assertEquals(self._decoder.mode, ADEMCO)

  233.         self.assertEquals(self._decoder.address, 18)

  234.         self.assertEquals(self._decoder.configbits, int('ff04', 16))

  235.         self.assertEquals(self._decoder.address_mask, int('ffffffff', 16))

  236.         self.assertEquals(self._decoder.emulate_zone, [False for x in range(5)])

  237.         self.assertEquals(self._decoder.emulate_relay, [False for x in range(4)])

  238.         self.assertFalse(self._decoder.emulate_lrr)

  239.         self.assertFalse(self._decoder.emulate_com)

  240.         self.assertFalse(self._decoder.deduplicate)

  241.         self.assertTrue(self._got_config)

  242. 

  243.     def test_power_changed_event(self):

  244.         msg = self._decoder._handle_message(b'[0000000100000000----],000,[f707000600e5800c0c020000],"                                "')

  245.         self.assertFalse(self._power_changed)   # Not set first time we hit it.

  246. 

  247.         msg = self._decoder._handle_message(b'[0000000000000000----],000,[f707000600e5800c0c020000],"                                "')

  248.         self.assertFalse(self._power_changed)

  249. 

  250.         msg = self._decoder._handle_message(b'[0000000100000000----],000,[f707000600e5800c0c020000],"                                "')

  251.         self.assertTrue(self._power_changed)

  252. 

  253.     def test_ready_changed_event(self):

  254.         msg = self._decoder._handle_message(b'[0000000000000000----],000,[f707000600e5800c0c020000],"                                "')

  255.         self.assertFalse(self._ready_changed)   # Not set first time we hit it.

  256. 

  257.         msg = self._decoder._handle_message(b'[1000000000000000----],000,[f707000600e5800c0c020000],"                                "')

  258.         self.assertTrue(self._ready_changed)

  259. 

  260.         msg = self._decoder._handle_message(b'[0000000000000000----],000,[f707000600e5800c0c020000],"                                "')

  261.         self.assertFalse(self._ready_changed)

  262. 

  263.     def test_chime_changed_event(self):

  264.         msg = self._decoder._handle_message(b'[0000000000000000----],000,[f707000600e5800c0c020000],"                                "')

  265.         self.assertFalse(self._chime_changed)   # Not set first time we hit it.

  266. 

  267.         msg = self._decoder._handle_message(b'[0000000010000000----],000,[f707000600e5800c0c020000],"                                "')

  268.         self.assertTrue(self._chime_changed)

  269. 

  270.         msg = self._decoder._handle_message(b'[0000000000000000----],000,[f707000600e5800c0c020000],"                                "')

  271.         self.assertFalse(self._chime_changed)

  272. 

  273.     def test_alarm_event(self):

  274.         msg = self._decoder._handle_message(b'[0000000000100000----],000,[f707000600e5800c0c020000],"                                "')

  275.         self.assertFalse(self._alarmed)   # Not set first time we hit it.

  276. 

  277.         msg = self._decoder._handle_message(b'[0000000000000000----],000,[f707000600e5800c0c020000],"                                "')

  278.         self.assertFalse(self._alarmed)

  279.         self.assertTrue(self._alarm_restored)

  280. 

  281.         msg = self._decoder._handle_message(b'[0000000000100000----],000,[f707000600e5800c0c020000],"                                "')

  282.         self.assertTrue(self._alarmed)

  283. 

  284.     def test_zone_bypassed_event(self):

  285.         msg = self._decoder._handle_message(b'[0000000000000000----],000,[f707000600e5800c0c020000],"                                "')

  286.         self.assertFalse(self._bypassed)

  287. 

  288.         msg = self._decoder._handle_message(b'[0000001000000000----],000,[f707000600e5800c0c020000],"                                "')

  289.         self.assertTrue(self._bypassed)

  290. 

  291.     def test_armed_away_event(self):

  292.         msg = self._decoder._handle_message(b'[0100000000000000----],000,[f707000600e5800c0c020000],"                                "')

  293.         self.assertFalse(self._armed)   # Not set first time we hit it.

  294. 

  295.         msg = self._decoder._handle_message(b'[0100000000000000----],000,[f707000600e5800c0c020000],"                                "')

  296.         self.assertFalse(self._armed)

  297. 

  298.         msg = self._decoder._handle_message(b'[0000000000000000----],000,[f707000600e5800c0c020000],"                                "')

  299.         self.assertFalse(self._armed)

  300. 

  301.         msg = self._decoder._handle_message(b'[0100000000000000----],000,[f707000600e5800c0c020000],"                                "')

  302.         self.assertTrue(self._armed)

  303. 

  304.         self._armed = False

  305.         msg = self._decoder._handle_message(b'[0010000000000000----],000,[f707000600e5800c0c020000],"                                "')

  306.         self.assertTrue(self._armed)

  307. 

  308.         msg = self._decoder._handle_message(b'[0000000000000000----],000,[f707000600e5800c0c020000],"                                "')

  309.         self.assertFalse(self._armed)

  310. 

  311.     def test_battery_low_event(self):

  312.         msg = self._decoder._handle_message(b'[0000000000010000----],000,[f707000600e5800c0c020000],"                                "')

  313.         self.assertTrue(self._battery)

  314. 

  315.         # force the timeout to expire.

  316.         with patch.object(time, 'time', return_value=self._decoder._battery_status[1] + 35):

  317.             msg = self._decoder._handle_message(b'[0000000000000000----],000,[f707000600e5800c0c020000],"                                "')

  318.             self.assertFalse(self._battery)

  319. 

  320.     def test_fire_alarm_event(self):

  321.         msg = self._decoder._handle_message(b'[0000000000000000----],000,[f707000600e5800c0c020000],"                                "')

  322.         self.assertFalse(self._fire)   # Not set the first time we hit it.

  323. 

  324.         msg = self._decoder._handle_message(b'[0000000000000100----],000,[f707000600e5800c0c020000],"                                "')

  325.         self.assertTrue(self._fire)

  326. 

  327.     def test_fire_lrr(self):

  328.         self._fire = False

  329. 

  330.         msg = self._decoder._handle_message(b'!LRR:095,1,CID_1110,ff') # Fire: Non-specific

  331. 

  332.         self.assertIsInstance(msg, LRRMessage)

  333.         self.assertTrue(self._fire)

  334. 

  335.         msg = self._decoder._handle_message(b'!LRR:001,1,CID_1406,ff') # Open/Close: Cancel

  336.         self.assertIsInstance(msg, LRRMessage)

  337.         self.assertFalse(self._fire)

  338. 

  339.     def test_hit_for_faults(self):

  340.         self._decoder._handle_message(b'[0000000000000000----],000,[f707000600e5800c0c020000],"Hit * for faults                "')

  341. 

  342.         self._decoder._device.write.assert_called_with(b'*')

  343. 

  344.     def test_sending_received(self):

  345.         self._decoder._on_read(self, data=b'!Sending.done')

  346.         self.assertTrue(self._sending_received_status)

  347. 

  348.         self._decoder._on_read(self, data=b'!Sending.....done')

  349.         self.assertFalse(self._sending_received_status)

  350. 

  351.     def test_boot(self):

  352.         self._decoder._on_read(self, data=b'!Ready')

  353.         self.assertTrue(self._on_boot_received)

  354. 

  355.     def test_zone_fault_and_restore(self):

  356.         self._decoder._on_read(self, data=b'[00010001000000000A--],003,[f70000051003000008020000000000],"FAULT 03                        "')

  357.         self.assertEquals(self._zone_faulted, 3)

  358. 

  359.         self._decoder._on_read(self, data=b'[00010001000000000A--],004,[f70000051003000008020000000000],"FAULT 04                        "')

  360.         self.assertEquals(self._zone_faulted, 4)

  361. 

  362.         self._decoder._on_read(self, data=b'[00010001000000000A--],005,[f70000051003000008020000000000],"FAULT 05                        "')

  363.         self.assertEquals(self._zone_faulted, 5)

  364. 

  365.         self._decoder._on_read(self, data=b'[00010001000000000A--],004,[f70000051003000008020000000000],"FAULT 04                        "')

  366.         self.assertEquals(self._zone_restored, 3)