def testGetTwoSetsOfUserDataFromPhone(self):
user_data_from_phone = [
{
"metadata": {
"write_ts": 1435856237,
"type": "rw-document",
"key": "diary/mode-confirmation",
},
"data" : {
"sid": "this-is-one-long-section-id",
"mode": "walking",
}
},
{
"metadata": {
"write_ts": 1435856337,
"type": "rw-document",
"key": "diary/mode-confirmation",
},
"data" : {
"sid": "this-is-two-long-section-id",
"mode": "cycling",
}
},
]
mauc.sync_phone_to_server(self.testUserUUID, user_data_from_phone)
uc = ucauc.UserCache.getUserCache(self.testUserUUID)
msgs = uc.getMessage(key_list = ["diary/mode-confirmation"])
self.assertEqual(len(msgs), 2)
self.assertEqual(msgs[0]["data"]["mode"], "walking")
def testGetTwoSetsOfUserDataFromPhone(self):
user_data_from_phone = [
{
"metadata": {
"write_ts": 1435856237,
"type": "rw-document",
"key": "diary/mode-confirmation",
},
"data": {
"sid": "this-is-one-long-section-id",
"mode": "walking",
}
},
{
"metadata": {
"write_ts": 1435856337,
"type": "rw-document",
"key": "diary/mode-confirmation",
},
"data": {
"sid": "this-is-two-long-section-id",
"mode": "cycling",
}
},
]
mauc.sync_phone_to_server(self.testUserUUID, user_data_from_phone)
uc = ucauc.UserCache.getUserCache(self.testUserUUID)
msgs = uc.getMessage(key_list=["diary/mode-confirmation"])
self.assertEqual(len(msgs), 2)
self.assertEqual(msgs[0]["data"]["mode"], "walking")
def putIntoOneEntry():
logging.debug("Called userCache.putone with request %s" % request)
user_uuid = getUUID(request)
logging.debug("user_uuid %s" % user_uuid)
the_entry = request.json['the_entry']
logging.debug("About to save entry %s" % the_entry)
# sync_phone_to_server requires a list, so we wrap our one entry in the list
from_phone = [the_entry]
usercache.sync_phone_to_server(user_uuid, from_phone)
return {"putone": True}
def testUserInputForTripOneInputFromCache(self):
"""
Test the case in which the user has provided exactly one input
"""
MODE_CONFIRM_KEY = "manual/mode_confirm"
new_trip = self.create_fake_trip()
new_mc = ecul.Userlabel()
new_mc["start_ts"] = new_trip.data.start_ts + 1
new_mc["end_ts"] = new_trip.data.end_ts + 1
new_mc["label"] = "roller_blading"
new_mce = ecwe.Entry.create_entry(self.testUserId, MODE_CONFIRM_KEY,
new_mc)
new_mce["metadata"]["type"] = "message"
enau.sync_phone_to_server(self.testUserId, [new_mce])
user_input = esdt.get_user_input_from_cache_series(
self.testUserId, new_trip, MODE_CONFIRM_KEY)
self.assertEqual(new_mce, user_input)
def setUp(self):
emission.tests.common.dropAllCollections(edb.get_db())
self.testUserUUID1 = uuid.uuid4()
self.testUserUUID2 = uuid.uuid4()
self.testUserUUIDios = uuid.uuid4()
self.activity_entry = json.load(open("emission/tests/data/netTests/android.activity.txt"))
self.location_entry = json.load(open("emission/tests/data/netTests/android.location.raw.txt"))
self.transition_entry = json.load(open("emission/tests/data/netTests/android.transition.txt"))
self.entry_list = [self.activity_entry, self.location_entry, self.transition_entry]
self.uc1 = enua.UserCache.getUserCache(self.testUserUUID1)
self.uc2 = enua.UserCache.getUserCache(self.testUserUUID2)
self.ucios = enua.UserCache.getUserCache(self.testUserUUIDios)
self.ts1 = esta.TimeSeries.get_time_series(self.testUserUUID1)
self.ts2 = esta.TimeSeries.get_time_series(self.testUserUUID2)
self.tsios = esta.TimeSeries.get_time_series(self.testUserUUIDios)
for entry in self.entry_list:
# Needed because otherwise we get a DuplicateKeyError while
# inserting the mutiple copies
del entry["_id"]
self.curr_ts = int(time.time())
for offset in range(self.curr_ts - 5 * 60, self.curr_ts, 30):
for entry in self.entry_list:
entry["metadata"]["write_ts"] = offset * 1000
mauc.sync_phone_to_server(self.testUserUUID1, self.entry_list)
for offset in range(self.curr_ts - 7 * 60 + 1, self.curr_ts - 2 * 60 + 1, 30):
for entry in self.entry_list:
entry["metadata"]["write_ts"] = offset * 1000
mauc.sync_phone_to_server(self.testUserUUID2, self.entry_list)
self.ios_activity_entry = json.load(open("emission/tests/data/netTests/ios.activity.txt"))
self.ios_location_entry = json.load(open("emission/tests/data/netTests/ios.location.txt"))
self.ios_transition_entry = json.load(open("emission/tests/data/netTests/ios.transition.txt"))
self.ios_entry_list = [self.ios_activity_entry, self.ios_location_entry, self.ios_transition_entry]
for entry in self.ios_entry_list:
# Needed because otherwise we get a DuplicateKeyError while
# inserting the mutiple copies
del entry["_id"]
for offset in range(self.curr_ts - 5 * 60, self.curr_ts, 30):
for entry in self.ios_entry_list:
entry["metadata"]["write_ts"] = offset
mauc.sync_phone_to_server(self.testUserUUIDios, self.ios_entry_list)
def setUp(self):
emission.tests.common.dropAllCollections(edb.get_db())
self.testUserUUID1 = uuid.uuid4()
self.testUserUUID2 = uuid.uuid4()
self.testUserUUIDios = uuid.uuid4()
self.activity_entry = json.load(open("emission/tests/data/netTests/android.activity.txt"))
self.location_entry = json.load(open("emission/tests/data/netTests/android.location.raw.txt"))
self.transition_entry = json.load(open("emission/tests/data/netTests/android.transition.txt"))
self.entry_list = [self.activity_entry, self.location_entry, self.transition_entry]
self.uc1 = enua.UserCache.getUserCache(self.testUserUUID1)
self.uc2 = enua.UserCache.getUserCache(self.testUserUUID2)
self.ucios = enua.UserCache.getUserCache(self.testUserUUIDios)
self.ts1 = esta.TimeSeries.get_time_series(self.testUserUUID1)
self.ts2 = esta.TimeSeries.get_time_series(self.testUserUUID2)
self.tsios = esta.TimeSeries.get_time_series(self.testUserUUIDios)
for entry in self.entry_list:
# Needed because otherwise we get a DuplicateKeyError while
# inserting the mutiple copies
del entry["_id"]
self.curr_ts = int(time.time())
for offset in range(self.curr_ts - 5 * 60, self.curr_ts, 30):
for entry in self.entry_list:
entry["metadata"]["write_ts"] = offset * 1000
mauc.sync_phone_to_server(self.testUserUUID1, self.entry_list)
for offset in range(self.curr_ts - 7 * 60 + 1, self.curr_ts - 2 * 60 + 1, 30):
for entry in self.entry_list:
entry["metadata"]["write_ts"] = offset * 1000
mauc.sync_phone_to_server(self.testUserUUID2, self.entry_list)
self.ios_activity_entry = json.load(open("emission/tests/data/netTests/ios.activity.txt"))
self.ios_location_entry = json.load(open("emission/tests/data/netTests/ios.location.txt"))
self.ios_transition_entry = json.load(open("emission/tests/data/netTests/ios.transition.txt"))
self.ios_entry_list = [self.ios_activity_entry, self.ios_location_entry, self.ios_transition_entry]
for entry in self.ios_entry_list:
# Needed because otherwise we get a DuplicateKeyError while
# inserting the mutiple copies
del entry["_id"]
for offset in range(self.curr_ts - 5 * 60, self.curr_ts, 30):
for entry in self.ios_entry_list:
entry["metadata"]["write_ts"] = offset
mauc.sync_phone_to_server(self.testUserUUIDios, self.ios_entry_list)
def setUp(self):
import emission.tests.common as etc
etc.dropAllCollections(edb._get_current_db())
self.testUserUUID1 = uuid.uuid4()
self.testUserUUID2 = uuid.uuid4()
self.testUserUUIDios = uuid.uuid4()
(self.entry_list, self.ios_entry_list) = etc.setupIncomingEntries()
self.uc1 = enua.UserCache.getUserCache(self.testUserUUID1)
self.uc2 = enua.UserCache.getUserCache(self.testUserUUID2)
self.ucios = enua.UserCache.getUserCache(self.testUserUUIDios)
self.ts1 = esta.TimeSeries.get_time_series(self.testUserUUID1)
self.ts2 = esta.TimeSeries.get_time_series(self.testUserUUID2)
self.tsios = esta.TimeSeries.get_time_series(self.testUserUUIDios)
for entry in self.entry_list:
# Needed because otherwise we get a DuplicateKeyError while
# inserting the mutiple copies
del entry["_id"]
self.curr_ts = int(time.time())
for offset in range(self.curr_ts - 5 * 60, self.curr_ts, 30):
for entry in self.entry_list:
entry["metadata"]["write_ts"] = offset
mauc.sync_phone_to_server(self.testUserUUID1, self.entry_list)
for offset in range(self.curr_ts - 7 * 60 + 1,
self.curr_ts - 2 * 60 + 1, 30):
for entry in self.entry_list:
entry["metadata"]["write_ts"] = offset
mauc.sync_phone_to_server(self.testUserUUID2, self.entry_list)
for entry in self.ios_entry_list:
# Needed because otherwise we get a DuplicateKeyError while
# inserting the mutiple copies
del entry["_id"]
for offset in range(self.curr_ts - 5 * 60, self.curr_ts, 30):
for entry in self.ios_entry_list:
entry["metadata"]["write_ts"] = offset
mauc.sync_phone_to_server(self.testUserUUIDios,
self.ios_entry_list)
def putIntoCache():
logging.debug("Called userCache.put")
user_uuid = getUUID(request)
logging.debug("user_uuid %s" % user_uuid)
from_phone = request.json['phone_to_server']
return usercache.sync_phone_to_server(user_uuid, from_phone)
def testClearBackgroundData(self):
start_ts = time.time()
background_data_from_phone = [
{
"metadata": {
"write_ts": time.time(),
"type": "message",
"key": "background/location",
},
"data" : { "mLat": 45.64, "mLng": 21.35, "mElapsedTime": 112233, }
},
{
"metadata": {
"write_ts": time.time(),
"type": "message",
"key": "background/activity",
},
"data" : { "mode": "walking", "confidence": 90 }
},
{
"metadata": {
"write_ts": time.time(),
"type": "message",
"key": "background/accelerometer",
},
"data" : {"x": 1234, "y": 2345, "z": 3456}
},
]
# sleep() expects an argument in seconds. We want to sleep for 5 ms.
time.sleep(old_div(float(5),1000))
background_data_from_phone_2 = [
{
"metadata": {
"write_ts": time.time(),
"type": "message",
"key": "background/location",
},
"data" : { "mLat": 49.64, "mLng": 25.35, "mElapsedTime": 142233, }
},
{
"metadata": {
"write_ts": time.time(),
"type": "message",
"key": "background/activity",
},
"data" : { "mode": "cycling", "confidence": 70 }
},
{
"metadata": {
"write_ts": time.time(),
"type": "message",
"key": "background/accelerometer",
},
"data" : {"x": 2345, "y": 3456, "z": 4567}
},
]
# We look for entries that are > 5 secs old, so it is fine to set the
# end_ts after all the entries have been inserted.
# If we don't add the fuzz factor of 5 seconds, then we sometimes end up
# with the first background entry having the same timestamp as end_ts
# and the counts don't work. We have a fuzz factor in the real world - lets'
# add one here as well
end_ts = time.time()
time.sleep(old_div(float(5), 1000))
background_data_from_phone_3 = [
{
"metadata": {
"write_ts": time.time(),
"type": "message",
"key": "background/location",
},
"data" : { "mLat": 45.64, "mLng": 21.35, "mElapsedTime": 112233, }
},
{
"metadata": {
"write_ts": time.time() + 30,
"type": "message",
"key": "background/location",
},
"data" : { "mLat": 49.64, "mLng": 25.35, "mElapsedTime": 142233, }
},
{
"metadata": {
"write_ts": time.time(),
"type": "message",
"key": "background/activity",
},
"data" : { "mode": "walking", "confidence": 90 }
},
{
"metadata": {
"write_ts": time.time() + 30,
"type": "message",
"key": "background/activity",
},
"data" : { "mode": "cycling", "confidence": 70 }
},
{
"metadata": {
"write_ts": time.time(),
"type": "message",
"key": "background/accelerometer",
},
"data" : {"x": 1234, "y": 2345, "z": 3456}
},
{
"metadata": {
"write_ts": time.time() + 30,
"type": "message",
"key": "background/accelerometer",
},
"data" : {"x": 2345, "y": 3456, "z": 4567}
},
]
mauc.sync_phone_to_server(self.testUserUUID, background_data_from_phone)
mauc.sync_phone_to_server(self.testUserUUID, background_data_from_phone_2)
mauc.sync_phone_to_server(self.testUserUUID, background_data_from_phone_3)
uc = ucauc.UserCache.getUserCache(self.testUserUUID)
tq = estt.TimeQuery("metadata.write_ts", start_ts, end_ts)
self.assertEqual(len(uc.getMessage(["background/location"], tq)), 2)
self.assertEqual(len(uc.getMessage(["background/activity"], tq)), 2)
self.assertEqual(len(uc.getMessage(["background/accelerometer"], tq)), 2)
uc.clearProcessedMessages(tq, ["background/location", "background/accelerometer"])
self.assertEqual(len(uc.getMessage(["background/accelerometer"], tq)), 0)
self.assertEqual(len(uc.getMessage(["background/location"], tq)), 0)
self.assertEqual(len(uc.getMessage(["background/activity"], tq)), 2)
def testGetTwoSetsOfBackgroundDataFromPhone(self):
background_data_from_phone = [
{
"metadata": {
"write_ts": 1435856235,
"type": "message",
"key": "background/location",
},
"data" : { "mLat": 45.64, "mLng": 21.35, "mElapsedTime": 112233, }
},
{
"metadata": {
"write_ts": 1435886337,
"type": "message",
"key": "background/location",
},
"data" : { "mLat": 49.64, "mLng": 25.35, "mElapsedTime": 142233, }
},
{
"metadata": {
"write_ts": 1435856337,
"type": "message",
"key": "background/activity",
},
"data" : { "mode": "walking", "confidence": 90 }
},
{
"metadata": {
"write_ts": 1435886337,
"type": "message",
"key": "background/activity",
},
"data" : { "mode": "cycling", "confidence": 70 }
},
{
"metadata": {
"write_ts": 1435856337,
"type": "message",
"key": "background/accelerometer",
},
"data" : {"x": 1234, "y": 2345, "z": 3456}
},
{
"metadata": {
"write_ts": 1435886337,
"type": "message",
"key": "background/accelerometer",
},
"data" : {"x": 2345, "y": 3456, "z": 4567}
},
]
mauc.sync_phone_to_server(self.testUserUUID, background_data_from_phone)
uc = ucauc.UserCache.getUserCache(self.testUserUUID)
self.assertEqual(len(uc.getMessage(["background/location"])), 2)
self.assertEqual(len(uc.getMessage(["background/activity"])), 2)
self.assertEqual(len(uc.getMessage(["background/accelerometer"])), 2)
self.assertEqual(uc.getMessage(["background/location"])[1]["data"]["mElapsedTime"], 142233)
self.assertEqual(uc.getMessage(["background/activity"])[1]["data"]["mode"], "cycling")
self.assertEqual(uc.getMessage(["background/accelerometer"])[1]["data"]["x"], 2345)
def testClearBackgroundData(self):
start_ts = time.time()
background_data_from_phone = [
{
"metadata": {
"write_ts": time.time(),
"type": "message",
"key": "background/location",
},
"data": {
"mLat": 45.64,
"mLng": 21.35,
"mElapsedTime": 112233,
}
},
{
"metadata": {
"write_ts": time.time(),
"type": "message",
"key": "background/activity",
},
"data": {
"mode": "walking",
"confidence": 90
}
},
{
"metadata": {
"write_ts": time.time(),
"type": "message",
"key": "background/accelerometer",
},
"data": {
"x": 1234,
"y": 2345,
"z": 3456
}
},
]
# sleep() expects an argument in seconds. We want to sleep for 5 ms.
time.sleep(float(5) / 1000)
background_data_from_phone_2 = [
{
"metadata": {
"write_ts": time.time(),
"type": "message",
"key": "background/location",
},
"data": {
"mLat": 49.64,
"mLng": 25.35,
"mElapsedTime": 142233,
}
},
{
"metadata": {
"write_ts": time.time(),
"type": "message",
"key": "background/activity",
},
"data": {
"mode": "cycling",
"confidence": 70
}
},
{
"metadata": {
"write_ts": time.time(),
"type": "message",
"key": "background/accelerometer",
},
"data": {
"x": 2345,
"y": 3456,
"z": 4567
}
},
]
time.sleep(float(5) / 1000)
# We look for entries that are > 5 secs old, so it is fine to set the
# end_ts after all the entries have been inserted.
end_ts = time.time()
background_data_from_phone_3 = [
{
"metadata": {
"write_ts": time.time(),
"type": "message",
"key": "background/location",
},
"data": {
"mLat": 45.64,
"mLng": 21.35,
"mElapsedTime": 112233,
}
},
{
"metadata": {
"write_ts": time.time() + 30,
"type": "message",
"key": "background/location",
},
"data": {
"mLat": 49.64,
"mLng": 25.35,
"mElapsedTime": 142233,
}
},
{
"metadata": {
"write_ts": time.time(),
"type": "message",
"key": "background/activity",
},
"data": {
"mode": "walking",
"confidence": 90
}
},
{
"metadata": {
"write_ts": time.time() + 30,
"type": "message",
"key": "background/activity",
},
"data": {
"mode": "cycling",
"confidence": 70
}
},
{
"metadata": {
"write_ts": time.time(),
"type": "message",
"key": "background/accelerometer",
},
"data": {
"x": 1234,
"y": 2345,
"z": 3456
}
},
{
"metadata": {
"write_ts": time.time() + 30,
"type": "message",
"key": "background/accelerometer",
},
"data": {
"x": 2345,
"y": 3456,
"z": 4567
}
},
]
mauc.sync_phone_to_server(self.testUserUUID,
background_data_from_phone)
mauc.sync_phone_to_server(self.testUserUUID,
background_data_from_phone_2)
mauc.sync_phone_to_server(self.testUserUUID,
background_data_from_phone_3)
uc = ucauc.UserCache.getUserCache(self.testUserUUID)
tq = ucauc.UserCache.TimeQuery("write_ts", start_ts, end_ts)
self.assertEqual(len(uc.getMessage(["background/location"], tq)), 2)
self.assertEqual(len(uc.getMessage(["background/activity"], tq)), 2)
self.assertEqual(len(uc.getMessage(["background/accelerometer"], tq)),
2)
uc.clearProcessedMessages(
tq, ["background/location", "background/accelerometer"])
self.assertEqual(len(uc.getMessage(["background/accelerometer"], tq)),
0)
self.assertEqual(len(uc.getMessage(["background/location"], tq)), 0)
self.assertEqual(len(uc.getMessage(["background/activity"], tq)), 2)
def testTwoLongTermCalls(self):
# First all the entries are in the usercache
self.assertEqual(len(self.uc1.getMessage()), 30)
self.assertEqual(len(list(self.ts1.find_entries())), 0)
self.assertEqual(len(self.ucios.getMessage()), 30)
self.assertEqual(len(list(self.tsios.find_entries())), 0)
# Then we move entries for user1 into longterm
enuah.UserCacheHandler.getUserCacheHandler(
self.testUserUUID1).moveToLongTerm()
# So we end up with all user1 entries in longterm
self.assertEqual(len(self.uc1.getMessage()), 0)
self.assertEqual(len(list(self.ts1.find_entries())), 30)
# Then, we move entries for the ios user into longterm
enuah.UserCacheHandler.getUserCacheHandler(
self.testUserUUIDios).moveToLongTerm()
self.assertEqual(len(self.ucios.getMessage()), 0)
self.assertEqual(len(list(self.tsios.find_entries())), 30)
# 30 entries from android + 30 entries from ios = 60
self.assertEqual(edb.get_timeseries_db().find().count(), 60)
self.assertEqual(edb.get_timeseries_error_db().find().count(), 0)
logging.debug("old curr_ts = %d" % self.curr_ts)
time.sleep(20)
self.curr_ts = int(time.time())
logging.debug("new curr_ts = %d" % self.curr_ts)
# Now, re-insert entries for android user1 and ios user1
for offset in range(self.curr_ts - 10, self.curr_ts):
for entry in self.entry_list:
entry["metadata"]["write_ts"] = offset * 1000
mauc.sync_phone_to_server(self.testUserUUID1, self.entry_list)
for offset in range(self.curr_ts - 10, self.curr_ts):
for entry in self.ios_entry_list:
entry["metadata"]["write_ts"] = offset
mauc.sync_phone_to_server(self.testUserUUIDios,
self.ios_entry_list)
# Now, repeat the above tests to ensure that they get moved again
self.assertEqual(len(self.uc1.getMessage()), 30)
# We will already have 30 entries in long-term for both android
self.assertEqual(len(list(self.ts1.find_entries())), 30)
self.assertEqual(len(self.ucios.getMessage()), 30)
# and ios
self.assertEqual(len(list(self.tsios.find_entries())), 30)
# The timequery is 5 secs into the past, to avoid races
# So let's sleep here for 5 secs
time.sleep(5)
# Then we move entries for user1 into longterm
enuah.UserCacheHandler.getUserCacheHandler(
self.testUserUUID1).moveToLongTerm()
# Now, we have two sets of entries, so we will have 60 entries in longterm
self.assertEqual(len(self.uc1.getMessage()), 0)
self.assertEqual(len(list(self.ts1.find_entries())), 60)
# Then, we move entries for the ios user into longterm
enuah.UserCacheHandler.getUserCacheHandler(
self.testUserUUIDios).moveToLongTerm()
self.assertEqual(len(self.ucios.getMessage()), 0)
self.assertEqual(len(list(self.tsios.find_entries())), 60)
# 60 entries from android + 60 entries from ios = 120
self.assertEqual(edb.get_timeseries_db().find().count(), 120)
self.assertEqual(edb.get_timeseries_error_db().find().count(), 0)
def putIntoCache():
logging.debug("Called userCache.put")
user_uuid=getUUID(request)
logging.debug("user_uuid %s" % user_uuid)
from_phone = request.json['phone_to_server']
return usercache.sync_phone_to_server(user_uuid, from_phone)
def testGetTwoSetsOfBackgroundDataFromPhone(self):
background_data_from_phone = [
{
"metadata": {
"write_ts": 1435856235,
"type": "message",
"key": "background/location",
},
"data": {
"mLat": 45.64,
"mLng": 21.35,
"mElapsedTime": 112233,
}
},
{
"metadata": {
"write_ts": 1435886337,
"type": "message",
"key": "background/location",
},
"data": {
"mLat": 49.64,
"mLng": 25.35,
"mElapsedTime": 142233,
}
},
{
"metadata": {
"write_ts": 1435856337,
"type": "message",
"key": "background/activity",
},
"data": {
"mode": "walking",
"confidence": 90
}
},
{
"metadata": {
"write_ts": 1435886337,
"type": "message",
"key": "background/activity",
},
"data": {
"mode": "cycling",
"confidence": 70
}
},
{
"metadata": {
"write_ts": 1435856337,
"type": "message",
"key": "background/accelerometer",
},
"data": {
"x": 1234,
"y": 2345,
"z": 3456
}
},
{
"metadata": {
"write_ts": 1435886337,
"type": "message",
"key": "background/accelerometer",
},
"data": {
"x": 2345,
"y": 3456,
"z": 4567
}
},
]
mauc.sync_phone_to_server(self.testUserUUID,
background_data_from_phone)
uc = ucauc.UserCache.getUserCache(self.testUserUUID)
self.assertEqual(len(uc.getMessage(["background/location"])), 2)
self.assertEqual(len(uc.getMessage(["background/activity"])), 2)
self.assertEqual(len(uc.getMessage(["background/accelerometer"])), 2)
self.assertEqual(
uc.getMessage(["background/location"])[1]["data"]["mElapsedTime"],
142233)
self.assertEqual(
uc.getMessage(["background/activity"])[1]["data"]["mode"],
"cycling")
self.assertEqual(
uc.getMessage(["background/accelerometer"])[1]["data"]["x"], 2345)
def testClearBackgroundData(self):
start_ts = time.time()
background_data_from_phone = [
{
"metadata": {
"write_ts": time.time(),
"type": "message",
"key": "background/location",
},
"data" : { "mLat": 45.64, "mLng": 21.35, "mElapsedTime": 112233, }
},
{
"metadata": {
"write_ts": time.time(),
"type": "message",
"key": "background/activity",
},
"data" : { "mode": "walking", "confidence": 90 }
},
{
"metadata": {
"write_ts": time.time(),
"type": "message",
"key": "background/accelerometer",
},
"data" : {"x": 1234, "y": 2345, "z": 3456}
},
]
# sleep() expects an argument in seconds. We want to sleep for 5 ms.
time.sleep(float(5)/1000)
background_data_from_phone_2 = [
{
"metadata": {
"write_ts": time.time(),
"type": "message",
"key": "background/location",
},
"data" : { "mLat": 49.64, "mLng": 25.35, "mElapsedTime": 142233, }
},
{
"metadata": {
"write_ts": time.time(),
"type": "message",
"key": "background/activity",
},
"data" : { "mode": "cycling", "confidence": 70 }
},
{
"metadata": {
"write_ts": time.time(),
"type": "message",
"key": "background/accelerometer",
},
"data" : {"x": 2345, "y": 3456, "z": 4567}
},
]
time.sleep(float(5)/ 1000)
# We look for entries that are > 5 secs old, so it is fine to set the
# end_ts after all the entries have been inserted.
end_ts = time.time()
background_data_from_phone_3 = [
{
"metadata": {
"write_ts": time.time(),
"type": "message",
"key": "background/location",
},
"data" : { "mLat": 45.64, "mLng": 21.35, "mElapsedTime": 112233, }
},
{
"metadata": {
"write_ts": time.time() + 30,
"type": "message",
"key": "background/location",
},
"data" : { "mLat": 49.64, "mLng": 25.35, "mElapsedTime": 142233, }
},
{
"metadata": {
"write_ts": time.time(),
"type": "message",
"key": "background/activity",
},
"data" : { "mode": "walking", "confidence": 90 }
},
{
"metadata": {
"write_ts": time.time() + 30,
"type": "message",
"key": "background/activity",
},
"data" : { "mode": "cycling", "confidence": 70 }
},
{
"metadata": {
"write_ts": time.time(),
"type": "message",
"key": "background/accelerometer",
},
"data" : {"x": 1234, "y": 2345, "z": 3456}
},
{
"metadata": {
"write_ts": time.time() + 30,
"type": "message",
"key": "background/accelerometer",
},
"data" : {"x": 2345, "y": 3456, "z": 4567}
},
]
mauc.sync_phone_to_server(self.testUserUUID, background_data_from_phone)
mauc.sync_phone_to_server(self.testUserUUID, background_data_from_phone_2)
mauc.sync_phone_to_server(self.testUserUUID, background_data_from_phone_3)
uc = ucauc.UserCache.getUserCache(self.testUserUUID)
tq = ucauc.UserCache.TimeQuery("write_ts", start_ts, end_ts)
self.assertEqual(len(uc.getMessage(["background/location"], tq)), 2)
self.assertEqual(len(uc.getMessage(["background/activity"], tq)), 2)
self.assertEqual(len(uc.getMessage(["background/accelerometer"], tq)), 2)
uc.clearProcessedMessages(tq, ["background/location", "background/accelerometer"])
self.assertEqual(len(uc.getMessage(["background/accelerometer"], tq)), 0)
self.assertEqual(len(uc.getMessage(["background/location"], tq)), 0)
self.assertEqual(len(uc.getMessage(["background/activity"], tq)), 2)
def testClearBackgroundData(self):
start_ts = time.time()
background_data_from_phone = [
{
"metadata": {
"write_ts": time.time(),
"type": "message",
"key": "background/location",
},
"data": {
"mLat": 45.64,
"mLng": 21.35,
"mElapsedTime": 112233,
}
},
{
"metadata": {
"write_ts": time.time(),
"type": "message",
"key": "background/activity",
},
"data": {
"mode": "walking",
"confidence": 90
}
},
{
"metadata": {
"write_ts": time.time(),
"type": "message",
"key": "background/accelerometer",
},
"data": {
"x": 1234,
"y": 2345,
"z": 3456
}
},
]
# sleep() expects an argument in seconds. We want to sleep for 5 ms.
time.sleep(float(5) / 1000)
background_data_from_phone_2 = [
{
"metadata": {
"write_ts": time.time(),
"type": "message",
"key": "background/location",
},
"data": {
"mLat": 49.64,
"mLng": 25.35,
"mElapsedTime": 142233,
}
},
{
"metadata": {
"write_ts": time.time(),
"type": "message",
"key": "background/activity",
},
"data": {
"mode": "cycling",
"confidence": 70
}
},
{
"metadata": {
"write_ts": time.time(),
"type": "message",
"key": "background/accelerometer",
},
"data": {
"x": 2345,
"y": 3456,
"z": 4567
}
},
]
# We look for entries that are > 5 secs old, so it is fine to set the
# end_ts after all the entries have been inserted.
# If we don't add the fuzz factor of 5 seconds, then we sometimes end up
# with the first background entry having the same timestamp as end_ts
# and the counts don't work. We have a fuzz factor in the real world - lets'
# add one here as well
end_ts = time.time()
time.sleep(float(5) / 1000)
background_data_from_phone_3 = [
{
"metadata": {
"write_ts": time.time(),
"type": "message",
"key": "background/location",
},
"data": {
"mLat": 45.64,
"mLng": 21.35,
"mElapsedTime": 112233,
}
},
{
"metadata": {
"write_ts": time.time() + 30,
"type": "message",
"key": "background/location",
},
"data": {
"mLat": 49.64,
"mLng": 25.35,
"mElapsedTime": 142233,
}
},
{
"metadata": {
"write_ts": time.time(),
"type": "message",
"key": "background/activity",
},
"data": {
"mode": "walking",
"confidence": 90
}
},
{
"metadata": {
"write_ts": time.time() + 30,
"type": "message",
"key": "background/activity",
},
"data": {
"mode": "cycling",
"confidence": 70
}
},
{
"metadata": {
"write_ts": time.time(),
"type": "message",
"key": "background/accelerometer",
},
"data": {
"x": 1234,
"y": 2345,
"z": 3456
}
},
{
"metadata": {
"write_ts": time.time() + 30,
"type": "message",
"key": "background/accelerometer",
},
"data": {
"x": 2345,
"y": 3456,
"z": 4567
}
},
]
mauc.sync_phone_to_server(self.testUserUUID,
background_data_from_phone)
mauc.sync_phone_to_server(self.testUserUUID,
background_data_from_phone_2)
mauc.sync_phone_to_server(self.testUserUUID,
background_data_from_phone_3)
uc = ucauc.UserCache.getUserCache(self.testUserUUID)
tq = estt.TimeQuery("metadata.write_ts", start_ts, end_ts)
self.assertEqual(len(uc.getMessage(["background/location"], tq)), 2)
self.assertEqual(len(uc.getMessage(["background/activity"], tq)), 2)
self.assertEqual(len(uc.getMessage(["background/accelerometer"], tq)),
2)
uc.clearProcessedMessages(
tq, ["background/location", "background/accelerometer"])
self.assertEqual(len(uc.getMessage(["background/accelerometer"], tq)),
0)
self.assertEqual(len(uc.getMessage(["background/location"], tq)), 0)
self.assertEqual(len(uc.getMessage(["background/activity"], tq)), 2)
def testTwoLongTermCalls(self):
# First all the entries are in the usercache
self.assertEqual(len(self.uc1.getMessage()), 30)
self.assertEqual(len(list(self.ts1.find_entries())), 0)
self.assertEqual(len(self.ucios.getMessage()), 30)
self.assertEqual(len(list(self.tsios.find_entries())), 0)
# Then we move entries for user1 into longterm
enuah.UserCacheHandler.getUserCacheHandler(self.testUserUUID1).moveToLongTerm()
# So we end up with all user1 entries in longterm
self.assertEqual(len(self.uc1.getMessage()), 0)
self.assertEqual(len(list(self.ts1.find_entries())), 30)
# Then, we move entries for the ios user into longterm
enuah.UserCacheHandler.getUserCacheHandler(self.testUserUUIDios).moveToLongTerm()
self.assertEqual(len(self.ucios.getMessage()), 0)
self.assertEqual(len(list(self.tsios.find_entries())), 30)
# 30 entries from android + 30 entries from ios = 60
self.assertEqual(edb.get_timeseries_db().find().count(), 60)
self.assertEqual(edb.get_timeseries_error_db().find().count(), 0)
logging.debug("old curr_ts = %d" % self.curr_ts)
time.sleep(20)
self.curr_ts = int(time.time())
logging.debug("new curr_ts = %d" % self.curr_ts)
# Now, re-insert entries for android user1 and ios user1
for offset in range(self.curr_ts - 10, self.curr_ts):
for entry in self.entry_list:
entry["metadata"]["write_ts"] = offset * 1000
mauc.sync_phone_to_server(self.testUserUUID1, self.entry_list)
for offset in range(self.curr_ts - 10, self.curr_ts):
for entry in self.ios_entry_list:
entry["metadata"]["write_ts"] = offset
mauc.sync_phone_to_server(self.testUserUUIDios, self.ios_entry_list)
# Now, repeat the above tests to ensure that they get moved again
self.assertEqual(len(self.uc1.getMessage()), 30)
# We will already have 30 entries in long-term for both android
self.assertEqual(len(list(self.ts1.find_entries())), 30)
self.assertEqual(len(self.ucios.getMessage()), 30)
# and ios
self.assertEqual(len(list(self.tsios.find_entries())), 30)
# The timequery is 5 secs into the past, to avoid races
# So let's sleep here for 5 secs
time.sleep(5)
# Then we move entries for user1 into longterm
enuah.UserCacheHandler.getUserCacheHandler(self.testUserUUID1).moveToLongTerm()
# Now, we have two sets of entries, so we will have 60 entries in longterm
self.assertEqual(len(self.uc1.getMessage()), 0)
self.assertEqual(len(list(self.ts1.find_entries())), 60)
# Then, we move entries for the ios user into longterm
enuah.UserCacheHandler.getUserCacheHandler(self.testUserUUIDios).moveToLongTerm()
self.assertEqual(len(self.ucios.getMessage()), 0)
self.assertEqual(len(list(self.tsios.find_entries())), 60)
# 60 entries from android + 60 entries from ios = 120
self.assertEqual(edb.get_timeseries_db().find().count(), 120)
self.assertEqual(edb.get_timeseries_error_db().find().count(), 0)
