def test_defaults(self):
"""
Tests whether creating a SensedEvent with minimum # arguments causes unexpected errors
or leads to a state that will later cause Exceptions to be raised when manipulating the event.
:return:
"""
ev = SensedEvent.from_json(self.minimal_event.to_json())
self.assertEqual(ev, self.minimal_event)
# Should be able to specify None values for the data (unary event) or source (anonymous event?)
ev = SensedEvent(data=1, source=None)
self.assertEqual(SensedEvent.from_json(ev.to_json()), ev)
ev = SensedEvent(data=None, source='temperature')
self.assertEqual(SensedEvent.from_json(ev.to_json()), ev)
def test_defaults(self):
"""
Tests whether creating a SensedEvent with minimum # arguments causes unexpected errors
or leads to a state that will later cause Exceptions to be raised when manipulating the event.
:return:
"""
ev = SensedEvent.from_json(self.minimal_event.to_json())
self.assertEqual(ev, self.minimal_event)
# Should be able to specify None values for the data (unary event) or source (anonymous event?)
ev = SensedEvent(data=1, source=None)
self.assertEqual(SensedEvent.from_json(ev.to_json()), ev)
ev = SensedEvent(data=None, source='temperature')
self.assertEqual(SensedEvent.from_json(ev.to_json()), ev)
class TestSensedEvent(unittest.TestCase):
"""
Test Scale client SensedEvent class for data manipulation, encoding, and decoding.
This should be used for testing different schema versions.
"""
def setUp(self):
self.event = SensedEvent(data=10,
source="temp0",
event_type="temperature")
self.minimal_event = SensedEvent(data=10, source="temp0")
def test_basic_json_encoding(self):
"""
Tests whether SensedEvent encoding/decoding works as expected.
:return:
"""
encoded = self.event.to_json()
decoded = SensedEvent.from_json(encoded)
self.assertEqual(
self.event, decoded,
"encoding then decoding an event should give an essentially identical one back! have: %s and %s"
% (self.event, decoded))
def test_json_encoding_excluded_fields(self):
"""
Tests whether we can correctly encode a SensedEvent with the exclude_fields option and then correctly decode
it back.
:return:
"""
encoded = self.event.to_json(exclude_fields=('schema', 'condition',
'misc', 'prio_value',
'prio_class'))
decoded = SensedEvent.from_json(encoded)
self.assertEqual(
self.event, decoded,
"encoding then decoding an event should give an essentially identical one back! have: %s and %s"
% (self.event, decoded))
# Now verify that excluding these fields at least allows us to decode the resulting encoded event, even though
# we KNOW that they will not be truly equal.
encoded = self.event.to_json(exclude_fields=('timestamp',
'event_type'))
decoded = SensedEvent.from_json(encoded) # should not raise error
# Last, verify that excluding these fields DOES cause an error!
encoded = self.event.to_json(exclude_fields=('device', ))
with self.assertRaises(NotImplementedError):
SensedEvent.from_json(encoded)
encoded = self.event.to_json(exclude_fields=('value', ))
with self.assertRaises(TypeError):
SensedEvent.from_json(encoded)
def test_schema_versions(self):
"""
Tests whether events formatted from different schema versions are compatible with the current data model.
:return:
"""
source_device = "scale-local:scale/devices/temperature"
v1_map = {
"d": {
"event": "temperature",
"value": 55.5,
"units": "celsius",
"timestamp": 12345678,
"device": source_device,
"location": {
"lat": 33.3,
"lon": "-71"
},
"condition": {
"threshold": {
"operator": ">",
"value": "95"
}
},
"prio_class": "high",
"prio_value": 2,
"schema": "www.schema.org/scale_sensors.1.0.whatever",
}
}
v1_event = SensedEvent.from_map(v1_map)
self.assertEqual(v1_event.event_type, 'temperature')
self.assertEqual(v1_event.data, 55.5)
self.assertEqual(v1_event.priority, 2)
self.assertEqual(v1_event.source, source_device)
# Now the other way around: dumping to a map, first by looking at JSON encoding...
v1_json = json.dumps(v1_map, sort_keys=True)
manual_v1_json = json.dumps(json.loads(v1_event.to_json()),
sort_keys=True)
self.assertEqual(manual_v1_json, v1_json)
new_v1_map = v1_event.to_map()
self.assertEqual(
v1_map, new_v1_map,
"making into v1.0 schema map didn't produce identical dict: %s" %
new_v1_map)
def test_source(self):
"""
Tests the special field "source" that be a plain string or URI representing a
VirtualSensor, DeviceDescriptor, etc... We especially want to make sure that simple
strings or None are handled well.
:return:
"""
# TODO: eventually look up objects by URI in order to determine if they refer to the same one?
# e.g. we should be able to have a remote device source that refers to a local one of ours be equal...
pass
def test_defaults(self):
"""
Tests whether creating a SensedEvent with minimum # arguments causes unexpected errors
or leads to a state that will later cause Exceptions to be raised when manipulating the event.
:return:
"""
ev = SensedEvent.from_json(self.minimal_event.to_json())
self.assertEqual(ev, self.minimal_event)
# Should be able to specify None values for the data (unary event) or source (anonymous event?)
ev = SensedEvent(data=1, source=None)
self.assertEqual(SensedEvent.from_json(ev.to_json()), ev)
ev = SensedEvent(data=None, source='temperature')
self.assertEqual(SensedEvent.from_json(ev.to_json()), ev)
def test_is_local(self):
"""
Tests whether we can properly determine whether a SensedEvent came from our local node or not.
:return:
"""
self.assertTrue(self.minimal_event.is_local,
"simple string source should be considered local!")
self.assertFalse(
SensedEvent(data=1,
source="coap://1.1.1.1/scale/events/temp").is_local,
"event from coap source is not local!")
class TestSensedEvent(unittest.TestCase):
"""
Test Scale client SensedEvent class for data manipulation, encoding, and decoding.
This should be used for testing different schema versions.
"""
def setUp(self):
self.event = SensedEvent(data=10, source="temp0", event_type="temperature")
self.minimal_event = SensedEvent(data=10, source="temp0")
def test_basic_json_encoding(self):
"""
Tests whether SensedEvent encoding/decoding works as expected.
:return:
"""
encoded = self.event.to_json()
decoded = SensedEvent.from_json(encoded)
self.assertEqual(self.event, decoded, "encoding then decoding an event should give an essentially identical one back! have: %s and %s" % (self.event, decoded))
def test_json_encoding_excluded_fields(self):
"""
Tests whether we can correctly encode a SensedEvent with the exclude_fields option and then correctly decode
it back.
:return:
"""
encoded = self.event.to_json(exclude_fields=('schema', 'condition', 'misc', 'prio_value', 'prio_class'))
decoded = SensedEvent.from_json(encoded)
self.assertEqual(self.event, decoded, "encoding then decoding an event should give an essentially identical one back! have: %s and %s" % (self.event, decoded))
# Now verify that excluding these fields at least allows us to decode the resulting encoded event, even though
# we KNOW that they will not be truly equal.
encoded = self.event.to_json(exclude_fields=('timestamp', 'event_type'))
decoded = SensedEvent.from_json(encoded) # should not raise error
# Last, verify that excluding these fields DOES cause an error!
encoded = self.event.to_json(exclude_fields=('device',))
with self.assertRaises(NotImplementedError):
SensedEvent.from_json(encoded)
encoded = self.event.to_json(exclude_fields=('value',))
with self.assertRaises(TypeError):
SensedEvent.from_json(encoded)
def test_schema_versions(self):
"""
Tests whether events formatted from different schema versions are compatible with the current data model.
:return:
"""
source_device = "scale-local:scale/devices/temperature"
v1_map = {"d" :
{"event" : "temperature",
"value" : 55.5,
"units" : "celsius",
"timestamp" : 12345678,
"device" : source_device,
"location" : {"lat" : 33.3, "lon" : "-71"},
"condition" : {"threshold" : {"operator" : ">", "value" : "95"}},
"prio_class": "high",
"prio_value": 2,
"schema" : "www.schema.org/scale_sensors.1.0.whatever",
}
}
v1_event = SensedEvent.from_map(v1_map)
self.assertEqual(v1_event.event_type, 'temperature')
self.assertEqual(v1_event.data, 55.5)
self.assertEqual(v1_event.priority, 2)
self.assertEqual(v1_event.source, source_device)
# Now the other way around: dumping to a map, first by looking at JSON encoding...
v1_json = json.dumps(v1_map, sort_keys=True)
manual_v1_json = json.dumps(json.loads(v1_event.to_json()), sort_keys=True)
self.assertEqual(manual_v1_json, v1_json)
new_v1_map = v1_event.to_map()
self.assertEqual(v1_map, new_v1_map, "making into v1.0 schema map didn't produce identical dict: %s" % new_v1_map)
def test_source(self):
"""
Tests the special field "source" that be a plain string or URI representing a
VirtualSensor, DeviceDescriptor, etc... We especially want to make sure that simple
strings or None are handled well.
:return:
"""
# TODO: eventually look up objects by URI in order to determine if they refer to the same one?
# e.g. we should be able to have a remote device source that refers to a local one of ours be equal...
pass
def test_defaults(self):
"""
Tests whether creating a SensedEvent with minimum # arguments causes unexpected errors
or leads to a state that will later cause Exceptions to be raised when manipulating the event.
:return:
"""
ev = SensedEvent.from_json(self.minimal_event.to_json())
self.assertEqual(ev, self.minimal_event)
# Should be able to specify None values for the data (unary event) or source (anonymous event?)
ev = SensedEvent(data=1, source=None)
self.assertEqual(SensedEvent.from_json(ev.to_json()), ev)
ev = SensedEvent(data=None, source='temperature')
self.assertEqual(SensedEvent.from_json(ev.to_json()), ev)
def test_is_local(self):
"""
Tests whether we can properly determine whether a SensedEvent came from our local node or not.
:return:
"""
self.assertTrue(self.minimal_event.is_local, "simple string source should be considered local!")
self.assertFalse(SensedEvent(data=1, source="coap://1.1.1.1/scale/events/temp").is_local,
"event from coap source is not local!")
