def testSensorAPIs(self):
self.sensor1 = Sensor.Create(self.e, "000-100", self.st.key().id())
self.sensor1.Update(name="Sensor 1")
self.sensor2 = Sensor.Create(self.e, "000-200", self.st.key().id())
db.put([self.sensor1, self.sensor2])
# Test list
params = self.__commonParams()
result = self.get_json("/api/sensor", params)
self.assertTrue(result['success'])
self.assertEqual(len(result['data']['sensors']), 2)
# Test detail
params = self.__commonParams()
params['with_records'] = 10
result = self.get_json("/api/sensor/%s" % "000-100", params)
self.assertTrue(result['success'])
self.assertEqual(result['data']['sensor']['name'], "Sensor 1")
# Test create with alias
params = self.__commonParams()
KN = "00-200"
params['kn'] = KN
params['name'] = "Geo Sensor 1"
params['sensortype_alias'] = "geo"
result = self.post_json("/api/sensor", params)
self.assertTrue(result['success'])
s = Sensor.get_by_key_name(KN, parent=self.e.key())
self.assertIsNotNone(s)
self.assertEqual(s.name, "Geo Sensor 1")
self.assertEqual(s.sensortype.key(), self.st.key())
def setUp(self):
self.set_application(tst_app)
self.setup_testbed()
self.init_datastore_stub()
self.init_memcache_stub()
self.init_taskqueue_stub()
self.init_app_identity_stub()
self.init_mail_stub()
self.register_search_api_stub()
self.init_urlfetch_stub()
self.init_blobstore_stub()
self.init_modules_stub()
cloudstorage.set_default_retry_params(None)
# Create enterprise, sensortype and sensor
self.e = Enterprise.Create()
self.e.Update(name="Test Ent", timezone="Africa/Nairobi")
self.e.put()
self.owner = User.Create(self.e, phone=OWNER_NUM, notify=False)
self.owner.Update(name=OWNER_NAME, currency="KES")
self.owner.put()
self.spedometer = SensorType.Create(self.e)
schema = {'speed': {'unit': 'kph'}, 'narrative': {'type': 'string'}}
self.spedometer.Update(name="Spedometer", schema=json.dumps(schema))
self.spedometer.put()
self.vehicle_1 = Sensor.Create(self.e, TEST_SENSOR_ID,
self.spedometer.key().id())
self.vehicle_1.Update(sensortype_id=self.spedometer.key().id(),
name="Vehicle Sensor 1")
self.vehicle_1.put()
def testRecordAPIs(self):
self.sensor1 = Sensor.Create(self.e, "000-100", self.st.key().id())
self.sensor1.put()
now = datetime.now()
r1_ts = tools.unixtime(now)
r = Record.Create(tools.unixtime(now), self.sensor1,
{'location': '51.5033640,-0.1276250'})
r2 = Record.Create(
tools.unixtime(now) + 1000, self.sensor1,
{'location': '51.5033640,-0.1276250'})
db.put([r, r2])
# Test list
params = self.__commonParams()
params.update({'sensor_kn': "000-100"})
result = self.get_json("/api/data", params)
self.assertTrue(result['success'])
self.assertEqual(len(result['data']['records']), 2)
# Test detail
params = self.__commonParams()
result = self.get_json("/api/data/%s/%s" % ("000-100", r1_ts), params)
self.assertTrue(result['success'])
_r = result['data']['record']
self.assertEqual(_r['sensor_kn'], "000-100")
self.assertEqual(_r['ts'], r1_ts)
self.assertEqual(
_r['kn'], "%s_%s_%s" %
(self.e.key().id(), self.sensor1.key().name(), int(r1_ts)))
def testAlarmWithPayment(self):
# Create smartphone report sensor
self.smartphone_sensor_type = SensorType.Create(self.e)
schema = {'agreement': {'unit': '1-5 scale'}}
self.smartphone_sensor_type.Update(name="Report Sensor",
schema=json.dumps(schema))
self.smartphone_sensor_type.put()
self.smartphone_sensor = Sensor.Create(
self.e, "1000",
self.smartphone_sensor_type.key().id())
self.smartphone_sensor.Update(
sensortype_id=self.smartphone_sensor_type.key().id(),
name="Smartphone Reports 1",
contacts={"user": self.owner.key().id()})
self.smartphone_sensor.put()
# Create smartphone report rule with payment on any report
PMNT_AMOUNT = 10.0
self.any_report_rule = Rule.Create(self.e)
self.any_report_rule.Update(
name="Any Report",
sensortype_id=self.smartphone_sensor_type.key().id(),
column="agreement",
trigger=RULE.ANY_DATA,
payment_contacts=["user"],
payment_amount=PMNT_AMOUNT,
consecutive_limit=RULE.
ANY, # Deactivate immediately (should be == 1)
duration=0)
self.any_report_rule.put()
self.assertTrue(self.any_report_rule.payments_enabled())
self.process = ProcessTask.Create(self.e)
self.process.Update(rule_ids=[self.any_report_rule.key().id()])
self.process.put()
# Apply our process to our sensor
self.sp = SensorProcessTask.Create(self.e, self.process,
self.smartphone_sensor)
self.sp.put()
BATCH_SIZE = 3
BATCH_1 = {
'agreement': [random.randint(1, 5) for x in range(BATCH_SIZE)],
}
self.__createNewRecords(BATCH_1,
first_dt=datetime.now(),
sensor=self.smartphone_sensor)
self.__runProcessing()
# This batch should have fired 3 alarms for any report, and created
# 3 payments.
pmnts = Payment.Fetch(self.owner)
self.assertEqual(len(pmnts), 3)
total_payments = BATCH_SIZE * PMNT_AMOUNT
self.assertEqual(total_payments, sum([p.amount for p in pmnts]))
def testGeoFenceAlarm(self):
self.geosensor = SensorType.Create(self.e)
schema = {
'location': {
'unit': 'deg',
'label': "Location",
'role': [COLUMN.LOCATION],
'type': 'latlng'
}
}
self.geosensor.Update(name="Geo Sensor", schema=json.dumps(schema))
self.geosensor.put()
# Create off route alarm
self.offroute_alarm = Rule.Create(self.e)
self.offroute_alarm.Update(name="Off Route",
sensortype_id=self.spedometer.key().id(),
column="location",
trigger=RULE.GEOFENCE_OUT,
value_complex=json.dumps(DUMMY_GEOFENCE))
self.offroute_alarm.put()
self.process = ProcessTask.Create(self.e)
self.process.Update(rule_ids=[self.offroute_alarm.key().id()])
self.process.put()
self.vehicle_2 = Sensor.Create(self.e, TEST_SENSOR_ID,
self.geosensor.key().id())
self.vehicle_2.Update(name="Vehicle Sensor 2")
# Apply our process to our sensor
self.sp = SensorProcessTask.Create(self.e, self.process,
self.vehicle_2)
self.sp.put()
# Process 8 location datapoints (3 in bounds, 3 out, 2 back in)
BATCH_1 = {
'location':
["%s,%s" % (coord[0], coord[1]) for coord in ROUTE_DIVERSION]
}
self.__createNewRecords(BATCH_1,
first_dt=datetime.now() -
timedelta(minutes=20),
interval_secs=30)
self.__runProcessing()
# Confirm off-route alarm fired upon datapoint 4, and deactivates on 7 (back in fence)
alarms = Alarm.Fetch(self.vehicle_2, self.offroute_alarm)
self.assertEqual(len(alarms), 1)
a = alarms[0]
first_record_in_alarm = a.first_record
self.assertEqual(a.duration().seconds,
60) # 3 datapoints, 30 second gap
oob_record = ROUTE_DIVERSION[3]
self.assertEqual(first_record_in_alarm.columnValue('location'),
"%s,%s" % (oob_record[0], oob_record[1]))
def setUp(self):
self.set_application(tst_app)
self.setup_testbed()
self.init_datastore_stub()
self.init_memcache_stub()
self.init_taskqueue_stub()
self.init_mail_stub()
self.register_search_api_stub()
self.init_urlfetch_stub()
self.init_modules_stub()
# Create enterprise, sensortype and sensor
self.e = Enterprise.Create()
self.e.Update(name="Test Ent", timezone="Africa/Nairobi")
self.e.put()
self.owner = User.Create(self.e, phone=OWNER_NUM, notify=False)
self.owner.Update(name=OWNER_NAME, currency="KES")
self.owner.put()
self.spedometer = SensorType.Create(self.e)
schema = {
'speed': {
'unit': 'kph'
},
'bearing': {
'unit': 'deg'
},
'location': {
'unit': 'degrees'
},
'hard_braking': {
'unit': 'boolean'
}
}
self.spedometer.Update(name="Geo Sensor", schema=json.dumps(schema))
self.spedometer.put()
self.vehicle_1 = Sensor.Create(self.e, TEST_SENSOR_ID,
self.spedometer.key().id())
self.vehicle_1.Update(sensortype_id=self.spedometer.key().id(),
name="Vehicle Sensor 1",
contacts={"owner": self.owner.key().id()})
self.vehicle_1.put()
# Create alarm
self.speeding_alarm = Rule.Create(self.e)
self.speeding_alarm.Update(name="Speeding",
sensortype_id=self.spedometer.key().id(),
column="speed",
trigger=RULE.CEILING,
value2=80.0,
alert_contacts=["owner"],
alert_message=SPEEDING_ALERT_MESSAGE,
duration=0)
self.speeding_alarm.put()
def setUp(self):
self.set_application(tst_app)
self.setup_testbed()
self.init_datastore_stub()
self.init_memcache_stub()
self.init_taskqueue_stub()
self.register_search_api_stub()
# Create enterprise, sensortype and sensor
self.e = Enterprise.Create()
self.e.Update(name="Test Ent")
self.e.put()
self.geosensor = SensorType.Create(self.e)
schema = {
'location': {
'unit': 'deg',
'label': "Location",
'role': [COLUMN.LOCATION]
},
'ax': {},
'ay': {
'unit': 'm/s^2',
'type': 'number'
},
'az': {
'unit': 'm/s^2',
'type': 'number'
},
'accel_mag': {
'unit': 'm/2^2',
'label': "Acceleration Magnitude",
'calculation': "SQRT([ax]^2 + [ay]^2 + [az]^2)"
}
}
self.geosensor.Update(name="Geo Sensor", schema=json.dumps(schema))
self.geosensor.put()
self.geosensor1 = Sensor.Create(self.e, TEST_SENSOR_ID,
self.geosensor.key().id())
self.geosensor1.Update(sensortype_id=self.geosensor.key().id(),
name="Geo Sensor 1")
self.geosensor1.put()
def setUp(self):
self.set_application(tst_app)
self.setup_testbed()
self.init_datastore_stub()
self.init_memcache_stub()
self.init_taskqueue_stub()
self.init_mail_stub()
self.register_search_api_stub()
self.init_urlfetch_stub()
self.init_modules_stub()
# Create enterprise, sensortype and sensor
self.e = Enterprise.Create()
self.e.Update(name="Test Ent", timezone="Africa/Nairobi")
self.e.put()
self.owner = User.Create(self.e, phone=OWNER_NUM, notify=False)
self.owner.Update(name=OWNER_NAME, currency="KES")
self.owner.put()
self.tracker = SensorType.Create(self.e)
schema = {
'bearing': {
'unit': 'deg'
},
'location': {
'unit': 'deg',
'label': "Location",
'role': [COLUMN.LOCATION],
'type': 'latlng'
}
}
self.tracker.Update(name="Geo Sensor", schema=json.dumps(schema))
self.tracker.put()
self.vehicle_1 = Sensor.Create(self.e, TEST_SENSOR_ID,
self.tracker.key().id())
self.vehicle_1.Update(sensortype_id=self.tracker.key().id(),
name="Vehicle Sensor 1",
contacts={"owner": self.owner.key().id()})
self.vehicle_1.put()
def testGeoRadiusAlarm(self):
# Create in radius alarm
self.in_radius_alarm = Rule.Create(self.e)
self.in_radius_alarm.Update(
name="In Town",
sensortype_id=self.tracker.key().id(),
column="location",
trigger=RULE.GEORADIUS_IN,
value2=RADIUS, # m
value_complex=json.dumps(RADIUS_CENTER),
alert_contacts=["owner"],
consecutive_limit=RULE.DISABLED,
duration=0)
self.in_radius_alarm.put()
self.process = ProcessTask.Create(self.e)
self.process.Update(rule_ids=[self.in_radius_alarm.key().id()])
self.process.put()
self.vehicle_2 = Sensor.Create(self.e, TEST_SENSOR_ID,
self.tracker.key().id())
self.vehicle_2.Update(name="Vehicle Sensor 2")
# Apply our process to our sensor
self.sp = SensorProcessTask.Create(self.e, self.process,
self.vehicle_2)
self.sp.put()
INTERVAL_SECS = 4
test_data_start = datetime.now() - timedelta(minutes=20)
# Process first data points entering radius
BATCH_1 = {
'location':
["%s,%s" % (coord[0], coord[1]) for coord in ENTERS_RADIUS]
}
last_record = self.__createNewRecords(BATCH_1,
first_dt=test_data_start,
interval_secs=INTERVAL_SECS)
self.__runProcessing()
# Confirm in-radius alarm fired upon datapoint 4...
alarms = Alarm.Fetch(self.vehicle_2, self.in_radius_alarm)
self.assertEqual(len(alarms), 1)
a = alarms[0]
# Process second batch of data points exiting radius
BATCH_2 = {
'location':
["%s,%s" % (coord[0], coord[1]) for coord in EXITS_RADIUS]
}
self.__createNewRecords(BATCH_2, interval_secs=INTERVAL_SECS)
self.__runProcessing()
# Confirm we still just have the single alarm record
alarms = Alarm.Fetch(self.vehicle_2, self.in_radius_alarm)
self.assertEqual(len(alarms), 1)
a = alarms[0]
duration_td = a.duration()
self.assertIsNotNone(duration_td)
# 3 datapoints in radius
print a.json()
def setUp(self):
self.set_application(tst_app)
self.setup_testbed()
self.init_datastore_stub()
self.init_memcache_stub()
self.init_taskqueue_stub()
self.init_mail_stub()
self.register_search_api_stub()
self.init_urlfetch_stub()
self.init_modules_stub()
# Create enterprise, sensortype and sensor
self.e = Enterprise.Create()
self.e.Update(name="Test Ent", timezone="Africa/Nairobi")
self.e.put()
self.tracker = SensorType.Create(self.e)
schema = {
'speed': {
'unit': 'kph'
},
'ign_on': {
'unit': 'boolean'
},
'ign_off': {
'unit': 'boolean'
}
}
self.tracker.Update(name="Tracker Sensor", schema=json.dumps(schema))
self.tracker.put()
self.vehicle_1 = Sensor.Create(self.e, TEST_SENSOR_ID, self.tracker.key().id())
self.vehicle_1.Update(
sensortype_id=self.tracker.key().id(),
name="Vehicle Sensor 1"
)
self.vehicle_1.put()
# Create alarm
self.ign_on_alarm = Rule.Create(self.e)
self.ign_on_alarm.Update(
name="Ignition On",
sensortype_id=self.tracker.key().id(),
column="ign_on",
trigger=RULE.CEILING,
value2=0,
consecutive_limit=-1,
duration=0)
self.ign_on_alarm.put()
self.ign_off_alarm = Rule.Create(self.e)
self.ign_off_alarm.Update(
name="Ignition Off",
sensortype_id=self.tracker.key().id(),
column="ign_off",
trigger=RULE.CEILING,
value2=0,
consecutive_limit=-1,
duration=0,
spec=json.dumps({'processers': [
{
'analysis_key_pattern': ANALYSIS_KEY_PATTERN,
'expr': '. + SINCE(LAST_ALARM(%d)) / 1000' % self.ign_on_alarm.key().id(),
'column': 'on_secs'
}
]}))
self.ign_off_alarm.put()
