def load_tags(self):
"""Load all registered tags."""
if self._needs_reload:
cookies = self._auth_cookies
try:
response = requests.post(self._GET_TAGS_URL,
headers=self._HEADERS,
cookies=cookies)
# remember time of load for cache/reload management
self._last_load_time = time.time()
json_tags_spec = response.json()
tags = json_tags_spec['d']
for tag in tags:
uuid = tag['uuid']
# save mac - a unique identifier of specific tag manager
mac = tag['mac'] if 'mac' in tag else None
self._tags[uuid] = SensorTag(tag, self, mac)
self._register_mac(mac)
_LOGGER.info("Tags reloaded at: %s", datetime.now())
except Exception as error:
_LOGGER.error("failed to load tags - %s", error)
return self._tags
def test_no_sensor_for_subscription(self):
"""Test for non-existing attribute."""
mac = '12'
tag = SensorTag(MOCK.PIRSENSOR, self.platform, mac)
with self.assertRaises(AttributeError):
no_message = tag.message
print('message: {}'.format(no_message))
def test_sensors(self):
"""Test sensors supported by tag."""
mac = '12'
tag = SensorTag(MOCK.PIRSENSOR, self.platform, mac)
sensor = tag.sensor[CONST.SENSOR_TEMPERATURE]
same_sensor = tag.sensor[CONST.SENSOR_TEMPERATURE]
self.assertIsNotNone(sensor)
self.assertTrue(sensor == same_sensor)
self.assertEqual(sensor.value, 23.924919128417969)
self.assertIsNotNone(str(sensor))
event = {
'name': 'Kitchen',
'id': 8,
'temp': 24.1517391204834,
'cap': 0,
'lux': 0,
'mac': '12'
}
value = sensor.value_from_update_event(event)
self.assertEqual(value, 24.1517391204834)
value = sensor.value_from_update_event({'name': 'no-exist'})
self.assertEqual(value, 0)
no_sensor = tag.sensor[CONST.SENSOR_LIGHT]
self.assertIsNone(no_sensor)
def _arm_control_tag(self,
tag_id,
url,
tag_manager_mac=None,
own_payload=None):
"""Arm sensor with specified id and url to monitor changes."""
cookies = self._auth_cookies
sensor_tag = None
try:
payload = json.dumps(({
"id": tag_id
} if own_payload is None else own_payload))
headers = self._headers_for_mac(tag_manager_mac)
response = requests.post(url,
headers=headers,
cookies=cookies,
data=payload)
json_tags_spec = response.json()
tag = json_tags_spec['d']
uuid = tag['uuid']
self._tags[uuid] = SensorTag(tag, self, tag_manager_mac)
sensor_tag = self._tags[uuid]
except Exception as error:
_LOGGER.error("failed to arm/disarm for tag id: %s - %s", tag_id,
error)
return sensor_tag
def test_switches(self):
"""Test allowed monitoring entities."""
mac = '12'
tag = SensorTag(MOCK.PIRSENSOR, self.platform, mac)
switch_types = tag.allowed_monitoring_types
self.assertIn(CONST.ARM_TEMPERATURE, switch_types)
self.assertIn(CONST.ARM_HUMIDITY, switch_types)
self.assertIn(CONST.ARM_MOTION, switch_types)
def _update_tags(self, tags):
"""Update tags arrived from server."""
updated_tags = {}
binary_events = {}
with self._update_lock:
for tag in tags:
uuid = tag['uuid']
# save mac - a unique identifier of specific tag manager
mac = tag['mac'] if 'mac' in tag else None
new_tag = SensorTag(tag, self, mac)
old_tag = self._tags[uuid] if uuid in self._tags else None
detected_events = new_tag.detected_events(old_tag)
if detected_events is not None and len(detected_events) > 0:
binary_events[uuid] = detected_events
self._tags[uuid] = new_tag
self._register_mac(mac)
updated_tags[uuid] = new_tag
return (updated_tags, binary_events)
def test_water_tag_binary_states(self):
"""Test avaiable binary states for als pro tag."""
tag = SensorTag(MOCK.WATERSENSOR, self.platform)
self.assertFalse(tag.is_moved)
self.assertFalse(tag.is_door_open)
self.assertFalse(tag.is_cold)
self.assertFalse(tag.is_heat)
self.assertFalse(tag.is_too_dry)
self.assertFalse(tag.is_too_humid)
self.assertTrue(tag.is_leaking)
self.assertFalse(tag.is_light_on)
self.assertFalse(tag.is_battery_low)
self.assertIsNotNone(str(tag))
def test_alspro_tag_binary_states(self):
"""Test avaiable binary states for als pro tag."""
tag = SensorTag(MOCK.ALS_PRO, self.platform, '0d0d0d0d0d0d')
self.assertTrue(tag.is_moved)
self.assertFalse(tag.is_door_open)
self.assertTrue(tag.is_cold)
self.assertFalse(tag.is_heat)
self.assertFalse(tag.is_too_dry)
self.assertFalse(tag.is_too_humid)
self.assertFalse(tag.is_leaking)
self.assertTrue(tag.is_light_on)
self.assertFalse(tag.is_battery_low)
self.assertIsNotNone(str(tag))
self.assertIsNotNone(tag.tag_manager_mac)
def test_motion_binary_event(self):
"""Test motion binary event for PIR sensor."""
mac = '12'
tag = SensorTag(MOCK.PIRSENSOR, self.platform, mac)
event = tag.event[CONST.EVENT_MOTION]
same_event = tag.event[CONST.EVENT_MOTION]
self.assertTrue(event == same_event)
self.assertIsNotNone(event)
self.assertFalse(event.is_state_on)
url = 'http://10.10.0.2/api/events/update_tags'
notifications = event.build_notifications(url, mac)
self.assertTrue(len(notifications) == 1)
config = notifications[0]
self.assertEqual(config.name, 'motion_detected')
self.assertTrue(config.is_enabled)
self.assertTrue(config.is_local)
self.assertEqual(config.url, url)
self.assertEqual(config.verb, 'POST')
def test_leak_binary_event(self):
"""Test water leak binary events logic."""
mac = '0d0d0d0d0d0d'
tag = SensorTag(MOCK.WATERSENSOR, self.platform, mac)
event = tag.event[CONST.EVENT_WET]
self.assertIsNone(event)
event = tag.event[CONST.EVENT_MOISTURE]
self.assertIsNotNone(event)
self.assertTrue(event.is_state_on)
url = 'http://10.10.0.2/api/events/update_tags'
notifications = event.build_notifications(url, mac)
self.assertTrue(len(notifications) == 2)
config = notifications[0]
self.assertTrue(config.name in ['water_detected', 'water_dried'])
self.assertTrue(config.is_enabled)
self.assertTrue(config.is_local)
self.assertEqual(config.url, url)
self.assertEqual(config.verb, 'POST')
def test_unknown_sensor_name(self):
"""Test avaiable binary states for als pro tag."""
tag = SensorTag(MOCK.TAG_UNKNOWN, self.platform, '0d0d0d0d0d0d')
self.assertEqual(tag.human_readable_name, "Tag type 15 rev.AF")