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): 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)