def testClientSpecificPrecompute(self):
for email in self.testUsers:
currUser = User.fromEmail(email)
self.assertEqual(currUser.getProfile().get("testfield1"), None)
self.assertEqual(currUser.getProfile().get("testfield2"), None)
self.assertEqual(data.getCarbonFootprint(currUser), None)
fakeEmail = "*****@*****.**"
client = Client("testclient")
client.update(createKey = False)
emission.tests.common.makeValid(client)
(resultPre, resultReg) = client.preRegister("this_is_the_super_secret_id", fakeEmail)
user = User.fromEmail(fakeEmail)
self.assertEqual(user.getFirstStudy(), 'testclient')
self.pr.precomputeResults()
self.assertEqual(user.getProfile()['testfield1'], 'value1')
self.assertEqual(user.getProfile()['testfield2'], 'value2')
for email in self.testUsers:
if email != fakeEmail:
currUser = User.fromEmail(email)
carbonFootprint = data.getCarbonFootprint(currUser)
self.assertEqual(len(carbonFootprint), 12)
def testQueryUnclassifiedSectionsLowConfidence(self):
fakeEmail = "*****@*****.**"
client = Client("testclient")
client.update(createKey = False)
emission.tests.common.makeValid(client)
(resultPre, resultReg) = client.preRegister("this_is_the_super_secret_id", fakeEmail)
self.assertEqual(resultPre, 0)
self.assertEqual(resultReg, 1)
user = User.fromEmail(fakeEmail)
self.assertEqual(user.getFirstStudy(), 'testclient')
queriedUnclassifiedSections = tripManager.queryUnclassifiedSections(User.fromEmail(fakeEmail).uuid)
self.assertEqual(queriedUnclassifiedSections.count(), 2)
# Set the auto_confirmed values for the trips
for section in queriedUnclassifiedSections:
print section['_id']
self.SectionsColl.update({'_id': section['_id']}, {'test_auto_confirmed': {'mode': section['mode'], 'prob': 0.95}})
# Now, set the update timestamp to two weeks ago so that we will start filtering
emission.tests.common.updateUserCreateTime(user.uuid)
queriedUnclassifiedSections = tripManager.queryUnclassifiedSections(User.fromEmail(fakeEmail).uuid)
self.assertEqual(queriedUnclassifiedSections.count(), 0)
def __preRegister(self, userEmail):
from emission.core.wrapper.user import User
from emission.analysis.result import userclient
if User.isRegistered(userEmail):
User.fromEmail(userEmail).setStudy(self.clientName)
else:
pendingDoc = {
'user_email': userEmail,
'study': self.clientName,
'last_update': datetime.now()
}
# Should I do insert or upsert here? If a user has pre-registered for one
# study and then pre-registers for another study before registering, do we
# want to throw an error or just update silently?
# Update silently for now
writeResult = get_pending_signup_db().update(
{'user_email': userEmail}, pendingDoc, upsert=True)
print 'in __preRegister, writeResult = %s' % writeResult
if 'err' in writeResult and writeResult['err'] is not None:
e = Exception()
e.code = writeResult['err'][0]["code"]
e.msg = writeResult['err'][0]["errmsg"]
raise e
return (get_pending_signup_db().find({
'study': self.clientName
}).count(), userclient.countForStudy(self.clientName))
def testQueryUnclassifiedSectionsWeekAgo(self):
# Add some old sections that shouldn't be returned by the query
# This one is just over a week old
old_sec_1 = self.SectionsColl.find_one({'$and': [{'user_id': User.fromEmail('*****@*****.**').uuid}, {'type':'move'}, {'mode':1}]})
old_sec_1['_id'] = 'old_sec_1'
old_sec_1['section_start_datetime'] = self.weekago - timedelta(minutes = 30)
old_sec_1['section_end_datetime'] = self.weekago - timedelta(minutes = 5)
logging.debug("Inserting old_sec_1 %s" % old_sec_1)
self.SectionsColl.insert(old_sec_1)
# This one is a month old
monthago = self.now - timedelta(days = 30)
old_sec_2 = self.SectionsColl.find_one({'$and': [{'user_id':User.fromEmail('*****@*****.**').uuid}, {'type':'move'}, {'mode':4}]})
old_sec_2['_id'] = 'old_sec_2'
old_sec_2['section_start_datetime'] = monthago - timedelta(minutes = 30)
old_sec_2['section_end_datetime'] = monthago - timedelta(minutes = 5)
logging.debug("Inserting old_sec_2 %s" % old_sec_2)
self.SectionsColl.insert(old_sec_2)
# This one is missing the predicted mode
monthago = self.now - timedelta(days = 30)
un_pred_sec = self.SectionsColl.find_one({'$and': [{'user_id':User.fromEmail('*****@*****.**').uuid}, {'type':'move'}, {'mode':4}]})
un_pred_sec['_id'] = 'un_pred_sec'
del un_pred_sec['predicted_mode']
logging.debug("Inserting un_pred_sec %s" % un_pred_sec)
self.SectionsColl.insert(un_pred_sec)
queriedUnclassifiedSections = tripManager.queryUnclassifiedSections(User.fromEmail('*****@*****.**').uuid)
self.assertEqual(queriedUnclassifiedSections.count(), 2)
def testClientSpecificPrecompute(self):
for email in self.testUsers:
currUser = User.fromEmail(email)
self.assertEqual(currUser.getProfile().get("testfield1"), None)
self.assertEqual(currUser.getProfile().get("testfield2"), None)
self.assertEqual(data.getCarbonFootprint(currUser), None)
fakeEmail = "*****@*****.**"
client = Client("testclient")
client.update(createKey=False)
emission.tests.common.makeValid(client)
(resultPre,
resultReg) = client.preRegister("this_is_the_super_secret_id",
fakeEmail)
user = User.fromEmail(fakeEmail)
self.assertEqual(user.getFirstStudy(), 'testclient')
self.pr.precomputeResults()
self.assertEqual(user.getProfile()['testfield1'], 'value1')
self.assertEqual(user.getProfile()['testfield2'], 'value2')
for email in self.testUsers:
if email != fakeEmail:
currUser = User.fromEmail(email)
carbonFootprint = data.getCarbonFootprint(currUser)
self.assertEqual(len(carbonFootprint), 12)
def testQueryUnclassifiedSectionsWeekAgo(self):
# Add some old sections that shouldn't be returned by the query
# This one is just over a week old
old_sec_1 = self.SectionsColl.find_one({
'$and': [{
'user_id': User.fromEmail('*****@*****.**').uuid
}, {
'type': 'move'
}, {
'mode': 1
}]
})
old_sec_1['_id'] = 'old_sec_1'
old_sec_1['section_start_datetime'] = self.weekago - timedelta(
minutes=30)
old_sec_1['section_end_datetime'] = self.weekago - timedelta(minutes=5)
logging.debug("Inserting old_sec_1 %s" % old_sec_1)
self.SectionsColl.insert(old_sec_1)
# This one is a month old
monthago = self.now - timedelta(days=30)
old_sec_2 = self.SectionsColl.find_one({
'$and': [{
'user_id': User.fromEmail('*****@*****.**').uuid
}, {
'type': 'move'
}, {
'mode': 4
}]
})
old_sec_2['_id'] = 'old_sec_2'
old_sec_2['section_start_datetime'] = monthago - timedelta(minutes=30)
old_sec_2['section_end_datetime'] = monthago - timedelta(minutes=5)
logging.debug("Inserting old_sec_2 %s" % old_sec_2)
self.SectionsColl.insert(old_sec_2)
# This one is missing the predicted mode
monthago = self.now - timedelta(days=30)
un_pred_sec = self.SectionsColl.find_one({
'$and': [{
'user_id': User.fromEmail('*****@*****.**').uuid
}, {
'type': 'move'
}, {
'mode': 4
}]
})
un_pred_sec['_id'] = 'un_pred_sec'
del un_pred_sec['predicted_mode']
logging.debug("Inserting un_pred_sec %s" % un_pred_sec)
self.SectionsColl.insert(un_pred_sec)
queriedUnclassifiedSections = tripManager.queryUnclassifiedSections(
User.fromEmail('*****@*****.**').uuid)
self.assertEqual(queriedUnclassifiedSections.count(), 2)
def testSavePredictionsStepWithClient(self):
from emission.core.wrapper.user import User
fakeEmail = "*****@*****.**"
client = Client("testclient")
client.update(createKey = False)
etc.makeValid(client)
(resultPre, resultReg) = client.preRegister("this_is_the_super_secret_id", fakeEmail)
self.assertEqual(resultPre, 0)
self.assertEqual(resultReg, 1)
user = User.fromEmail(fakeEmail)
self.assertEqual(user.getFirstStudy(), 'testclient')
self.testPredictedProb()
self.pipeline.savePredictionsStep()
# Confirm that the predictions are saved correctly
test_id_1_sec = self.SectionsColl.find_one({'_id': 'test_id_1'})
self.assertIsNotNone(test_id_1_sec['predicted_mode'])
self.assertEquals(test_id_1_sec['predicted_mode'], {'walking': 1})
self.assertEquals(test_id_1_sec['test_auto_confirmed'], {'mode': 1, 'prob': 1.0})
test_id_2_sec = self.SectionsColl.find_one({'_id': 'test_id_2'})
self.assertIsNotNone(test_id_2_sec['predicted_mode'])
self.assertEquals(test_id_2_sec['predicted_mode'], {'bus': 1})
self.assertEquals(test_id_2_sec['test_auto_confirmed'], {'mode': 5, 'prob': 1.0})
# Let's make sure that we didn't accidentally mess up other fields
self.assertIsNotNone(test_id_1_sec['distance'])
self.assertIsNotNone(test_id_2_sec['trip_id'])
def testSavePredictionsStepWithClient(self):
from emission.core.wrapper.user import User
fakeEmail = "*****@*****.**"
client = Client("testclient")
client.update(createKey = False)
emission.tests.common.makeValid(client)
(resultPre, resultReg) = client.preRegister("this_is_the_super_secret_id", fakeEmail)
self.assertEqual(resultPre, 0)
self.assertEqual(resultReg, 1)
user = User.fromEmail(fakeEmail)
self.assertEqual(user.getFirstStudy(), 'testclient')
self.testPredictedProb()
self.pipeline.savePredictionsStep()
# Confirm that the predictions are saved correctly
test_id_1_sec = self.SectionsColl.find_one({'_id': 'test_id_1'})
self.assertIsNotNone(test_id_1_sec['predicted_mode'])
self.assertEquals(test_id_1_sec['predicted_mode'], {'walking': 1})
self.assertEquals(test_id_1_sec['test_auto_confirmed'], {'mode': 1, 'prob': 1.0})
test_id_2_sec = self.SectionsColl.find_one({'_id': 'test_id_2'})
self.assertIsNotNone(test_id_2_sec['predicted_mode'])
self.assertEquals(test_id_2_sec['predicted_mode'], {'bus': 1})
self.assertEquals(test_id_2_sec['test_auto_confirmed'], {'mode': 5, 'prob': 1.0})
# Let's make sure that we didn't accidentally mess up other fields
self.assertIsNotNone(test_id_1_sec['distance'])
self.assertIsNotNone(test_id_2_sec['trip_id'])
def setUp(self):
self.testUsers = [
"*****@*****.**", "*****@*****.**", "*****@*****.**",
"*****@*****.**", "*****@*****.**"
]
self.serverName = edb.url
self.ModesColl = get_mode_db()
self.SectionsColl = get_section_db()
# Let's make sure that the users are registered so that they have profiles
user_objects = []
for userEmail in self.testUsers:
user_objects.append(User.register(userEmail))
# Sometimes, we may have entries left behind in the database if one of the tests failed
# or threw an exception, so let us start by cleaning up all entries
for testUser in user_objects:
etc.purgeSectionData(self.SectionsColl, testUser.uuid)
if self.ModesColl.estimated_document_count() > 0:
self.ModesColl.delete_many({})
self.assertEqual(self.ModesColl.estimated_document_count(), 0)
self.assertEqual(self.SectionsColl.estimated_document_count(), 0)
MongoClient(edb.url).drop_database("Backup_database")
etc.loadTable(self.serverName, "Stage_Modes",
"emission/tests/data/modes.json")
etc.loadTable(self.serverName, "Stage_Sections",
"emission/tests/data/testModeInferSeedFile")
self.now = datetime.now()
self.dayago = self.now - timedelta(days=1)
self.weekago = self.now - timedelta(weeks=1)
for section in self.SectionsColl.find():
section['section_start_datetime'] = self.dayago
section['section_end_datetime'] = self.dayago + timedelta(hours=1)
if (section['confirmed_mode'] == 5):
# We only cluster bus and train trips
# And our test data only has bus trips
section['section_start_point'] = {
u'type': u'Point',
u'coordinates': [-122.270039042, 37.8800285728]
}
section['section_end_point'] = {
u'type': u'Point',
u'coordinates': [-122.2690412952, 37.8739578595]
}
# print("Section start = %s, section end = %s" %
# (section['section_start_datetime'], section['section_end_datetime']))
# Replace the user email with the UUID
section['user_id'] = User.fromEmail(section['user_id']).uuid
edb.save(self.SectionsColl, section)
self.pipeline = pipeline.ModeInferencePipelineMovesFormat()
self.testLoadTrainingData()
def testGetUnclassifiedSectionsFiltered(self):
"""
Tests that queryUnclassifiedSections never returns
a section with section['retained'] == False. A section is only returned if
section['retained'] == True and all other query conditions are met
"""
# Clear previous Stage_Sections data and load new data
# specific to filtering
self.SectionsColl.remove()
emission.tests.common.loadTable(self.serverName, "Stage_Sections",
"emission/tests/data/testFilterFile")
emission.tests.common.updateSections(self)
# Extra updates to Sections necessary for testing filtering
for section in self.SectionsColl.find():
section['section_start_point'] = "filler start point"
section['section_end_point'] = "filler end point"
self.SectionsColl.save(section)
fakeEmail = "*****@*****.**"
client = Client("testclient")
client.update(createKey=False)
emission.tests.common.makeValid(client)
(resultPre,
resultReg) = client.preRegister("this_is_the_super_secret_id",
fakeEmail)
self.assertEqual(resultPre, 0)
self.assertEqual(resultReg, 1)
user = User.fromEmail(fakeEmail)
self.assertEqual(user.getFirstStudy(), 'testclient')
unclassifiedSections = tripManager.getUnclassifiedSections(
User.fromEmail(fakeEmail).uuid)['sections']
# Check that of the valid sections in the testFilterFile (2/3), only one of them is returned by the query
self.assertEqual(len(unclassifiedSections), 1)
# Check that the second entry in the testFilterFile is the only section
# that is loaded into the database
self.assertEqual('20140401T095742-0700',
unclassifiedSections[0]['trip_id'])
def register_user(userEmail):
"""
Does some sanity checking and then registers the user with the specified email address.
This is useful for testing.
"""
if User.fromEmail(userEmail) is not None:
raise RuntimeError("User with email %s already exists" % userEmail)
userObj = User.register(userEmail)
print "Registration successful!"
print "User profile is %s" % userObj.getProfile();
def register_user(userEmail):
"""
Does some sanity checking and then registers the user with the specified email address.
This is useful for testing.
"""
if User.fromEmail(userEmail) is not None:
raise RuntimeError("User with email %s already exists" % userEmail)
userObj = User.register(userEmail)
print "Registration successful!"
print "User profile is %s" % userObj.getProfile()
def setUp(self):
self.testUsers = [
"*****@*****.**", "*****@*****.**", "*****@*****.**",
"*****@*****.**", "*****@*****.**"
]
self.serverName = 'localhost'
# Sometimes, we may have entries left behind in the database if one of the tests failed
# or threw an exception, so let us start by cleaning up all entries
emission.tests.common.dropAllCollections(get_db())
self.ModesColl = get_mode_db()
self.assertEquals(self.ModesColl.find().count(), 0)
self.SectionsColl = get_section_db()
self.assertEquals(self.SectionsColl.find().count(), 0)
emission.tests.common.loadTable(self.serverName, "Stage_Modes",
"emission/tests/data/modes.json")
emission.tests.common.loadTable(
self.serverName, "Stage_Sections",
"emission/tests/data/testModeInferFile")
# Let's make sure that the users are registered so that they have profiles
for userEmail in self.testUsers:
User.register(userEmail)
self.now = datetime.now()
self.dayago = self.now - timedelta(days=1)
self.weekago = self.now - timedelta(weeks=1)
for section in self.SectionsColl.find():
section['section_start_datetime'] = self.dayago
section['section_end_datetime'] = self.dayago + timedelta(hours=1)
if (section['confirmed_mode'] == 5):
# We only cluster bus and train trips
# And our test data only has bus trips
section['section_start_point'] = {
u'type': u'Point',
u'coordinates': [-122.270039042, 37.8800285728]
}
section['section_end_point'] = {
u'type': u'Point',
u'coordinates': [-122.2690412952, 37.8739578595]
}
# print("Section start = %s, section end = %s" %
# (section['section_start_datetime'], section['section_end_datetime']))
# Replace the user email with the UUID
section['user_id'] = User.fromEmail(section['user_id']).uuid
self.SectionsColl.save(section)
self.pipeline = pipeline.ModeInferencePipeline()
self.testLoadTrainingData()
def testGetFirstStudy(self):
user = User.register('*****@*****.**')
self.assertTrue(User.isRegistered('*****@*****.**'))
client = Client("testclient")
client.update(createKey = False)
common.makeValid(client)
(resultPre, resultReg) = client.preRegister("this_is_the_super_secret_id", "*****@*****.**")
self.assertEqual(resultPre, 0)
self.assertEqual(resultReg, 1)
user = User.fromEmail('*****@*****.**')
self.assertEqual(user.getFirstStudy(), 'testclient')
def testGetFirstStudy(self):
user = User.register('*****@*****.**')
self.assertTrue(User.isRegistered('*****@*****.**'))
client = Client("testclient")
client.update(createKey = False)
common.makeValid(client)
(resultPre, resultReg) = client.preRegister("this_is_the_super_secret_id", "*****@*****.**")
self.assertEqual(resultPre, 0)
self.assertEqual(resultReg, 1)
user = User.fromEmail('*****@*****.**')
self.assertEqual(user.getFirstStudy(), 'testclient')
def testGetUnclassifiedSectionsFiltered(self):
"""
Tests that queryUnclassifiedSections never returns
a section with section['retained'] == False. A section is only returned if
section['retained'] == True and all other query conditions are met
"""
# Clear previous Stage_Sections data and load new data
# specific to filtering
self.SectionsColl.remove()
emission.tests.common.loadTable(self.serverName, "Stage_Sections", "emission/tests/data/testFilterFile")
emission.tests.common.updateSections(self)
# Extra updates to Sections necessary for testing filtering
for section in self.SectionsColl.find():
section['section_start_point'] = "filler start point"
section['section_end_point'] = "filler end point"
self.SectionsColl.save(section)
fakeEmail = "*****@*****.**"
client = Client("testclient")
client.update(createKey = False)
emission.tests.common.makeValid(client)
(resultPre, resultReg) = client.preRegister("this_is_the_super_secret_id", fakeEmail)
self.assertEqual(resultPre, 0)
self.assertEqual(resultReg, 1)
user = User.fromEmail(fakeEmail)
self.assertEqual(user.getFirstStudy(), 'testclient')
unclassifiedSections = tripManager.getUnclassifiedSections(User.fromEmail(fakeEmail).uuid)['sections']
# Check that of the valid sections in the testFilterFile (2/3), only one of them is returned by the query
self.assertEqual(len(unclassifiedSections), 1)
# Check that the second entry in the testFilterFile is the only section
# that is loaded into the database
self.assertEqual('20140401T095742-0700',unclassifiedSections[0]['trip_id'])
def testQueryUnclassifiedSectionsLowConfidence(self):
fakeEmail = "*****@*****.**"
client = Client("testclient")
client.update(createKey=False)
emission.tests.common.makeValid(client)
(resultPre,
resultReg) = client.preRegister("this_is_the_super_secret_id",
fakeEmail)
self.assertEqual(resultPre, 0)
self.assertEqual(resultReg, 1)
user = User.fromEmail(fakeEmail)
self.assertEqual(user.getFirstStudy(), 'testclient')
queriedUnclassifiedSections = tripManager.queryUnclassifiedSections(
User.fromEmail(fakeEmail).uuid)
self.assertEqual(queriedUnclassifiedSections.count(), 2)
# Set the auto_confirmed values for the trips
for section in queriedUnclassifiedSections:
print section['_id']
self.SectionsColl.update({'_id': section['_id']}, {
'test_auto_confirmed': {
'mode': section['mode'],
'prob': 0.95
}
})
# Now, set the update timestamp to two weeks ago so that we will start filtering
emission.tests.common.updateUserCreateTime(user.uuid)
queriedUnclassifiedSections = tripManager.queryUnclassifiedSections(
User.fromEmail(fakeEmail).uuid)
self.assertEqual(queriedUnclassifiedSections.count(), 0)
def __preRegister(self, userEmail):
from emission.core.wrapper.user import User
from emission.analysis.result import userclient
if User.isRegistered(userEmail):
User.fromEmail(userEmail).setStudy(self.clientName)
else:
pendingDoc = {
'user_email': userEmail,
'study': self.clientName,
'last_update': datetime.now()}
# Should I do insert or upsert here? If a user has pre-registered for one
# study and then pre-registers for another study before registering, do we
# want to throw an error or just update silently?
# Update silently for now
writeResult = get_pending_signup_db().update({'user_email': userEmail}, pendingDoc, upsert=True)
print 'in __preRegister, writeResult = %s' % writeResult
if 'err' in writeResult and writeResult['err'] is not None:
e = Exception()
e.code = writeResult['err'][0]["code"]
e.msg = writeResult['err'][0]["errmsg"]
raise e
return (get_pending_signup_db().find({'study': self.clientName}).count(),
userclient.countForStudy(self.clientName))
def setUp(self):
self.testUsers = [
"*****@*****.**",
"*****@*****.**",
"*****@*****.**",
"*****@*****.**",
"*****@*****.**",
]
self.serverName = "localhost"
# Sometimes, we may have entries left behind in the database if one of the tests failed
# or threw an exception, so let us start by cleaning up all entries
emission.tests.common.dropAllCollections(get_db())
self.ModesColl = get_mode_db()
self.assertEquals(self.ModesColl.find().count(), 0)
self.SectionsColl = get_section_db()
self.assertEquals(self.SectionsColl.find().count(), 0)
emission.tests.common.loadTable(self.serverName, "Stage_Modes", "emission/tests/data/modes.json")
emission.tests.common.loadTable(self.serverName, "Stage_Sections", "emission/tests/data/testModeInferFile")
# Let's make sure that the users are registered so that they have profiles
for userEmail in self.testUsers:
User.register(userEmail)
self.now = datetime.now()
self.dayago = self.now - timedelta(days=1)
self.weekago = self.now - timedelta(weeks=1)
for section in self.SectionsColl.find():
section["section_start_datetime"] = self.dayago
section["section_end_datetime"] = self.dayago + timedelta(hours=1)
if section["confirmed_mode"] == 5:
# We only cluster bus and train trips
# And our test data only has bus trips
section["section_start_point"] = {u"type": u"Point", u"coordinates": [-122.270039042, 37.8800285728]}
section["section_end_point"] = {u"type": u"Point", u"coordinates": [-122.2690412952, 37.8739578595]}
# print("Section start = %s, section end = %s" %
# (section['section_start_datetime'], section['section_end_datetime']))
# Replace the user email with the UUID
section["user_id"] = User.fromEmail(section["user_id"]).uuid
self.SectionsColl.save(section)
self.pipeline = pipeline.ModeInferencePipeline()
self.testLoadTrainingData()
def updateSections(testCase):
from emission.core.wrapper.user import User
"""
Updates sections with appropriate test data
Should be called anytime new data is loaded into the
'Stage_Sections' table
"""
testCase.uuid_list = []
for section in testCase.SectionsColl.find():
section['section_start_datetime'] = testCase.dayago
section['section_end_datetime'] = testCase.dayago + timedelta(hours = 1)
section['predicted_mode'] = [0, 0.4, 0.6, 0]
section['confirmed_mode'] = ''
# Replace the user email with the UUID
curr_uuid = User.fromEmail(section['user_id']).uuid
section['user_id'] = curr_uuid
testCase.uuid_list.append(curr_uuid)
testCase.SectionsColl.save(section)
def testRegisterExistingUser(self):
user = User.register('*****@*****.**')
self.assertEquals(user.getStudy(), [])
client = Client("testclient")
client.update(createKey = False)
common.makeValid(client)
(resultPre, resultReg) = client.preRegister("this_is_the_super_secret_id", "*****@*****.**")
self.assertEqual(resultPre, 0)
self.assertEqual(resultReg, 1)
user = User.fromEmail("*****@*****.**")
self.assertEquals(user.getStudy(), ['testclient'])
# Here's the key difference, now register again
user = User.register('*****@*****.**')
self.assertEquals(user.getStudy(), ['testclient'])
def testRegisterExistingUser(self):
user = User.register('*****@*****.**')
self.assertEquals(user.getStudy(), [])
client = Client("testclient")
client.update(createKey = False)
common.makeValid(client)
(resultPre, resultReg) = client.preRegister("this_is_the_super_secret_id", "*****@*****.**")
self.assertEqual(resultPre, 0)
self.assertEqual(resultReg, 1)
user = User.fromEmail("*****@*****.**")
self.assertEquals(user.getStudy(), ['testclient'])
# Here's the key difference, now register again
user = User.register('*****@*****.**')
self.assertEquals(user.getStudy(), ['testclient'])
def testStoreSensedTrips(self):
fakeEmail = "*****@*****.**"
fakeUUID = User.fromEmail(fakeEmail).uuid
trip_array = json.load(open("emission/tests/data/sensed_trips.json"))
self.assertEqual(len(trip_array), 2)
tripManager.storeSensedTrips(fakeUUID, trip_array)
insertedTrips = [trip for trip in get_trip_db().find({"user_id": fakeUUID})]
# We load two sections for each user in the setup. Here we only want to
# look at sections that we added here. We distinguish between the two by looking
# to see whether the predicted mode exists
insertedSections = [section for section in get_section_db().find({"$and":
[{"user_id": fakeUUID}, {"predicted_mode": {"$exists": False}}]})]
# insertedSections = [section["predicted_mode"] for section in get_section_db().find({"user_id": fakeUUID})]
self.assertEqual(len(insertedTrips), 2)
self.assertEqual(insertedTrips[0]["type"], "place")
self.assertEqual(insertedTrips[0]["trip_start_time"], "20150101T000153-0500")
# self.assertEqual(insertedTrips[0]["trip_start_datetime"], datetime(2014,12,31,17,31,52))
self.assertEqual(insertedTrips[0]["trip_end_time"], "20150102T000252-0500")
# self.assertEqual(insertedTrips[0]["trip_end_datetime"], datetime(2015,01,02,04,01,51))
startPlaceLocation = insertedTrips[0]["place"]["place_location"]
self.assertEqual(startPlaceLocation["coordinates"], [-122.086945, 37.380866])
self.assertEqual(insertedTrips[1]["type"], "move")
self.assertEqual(insertedTrips[1]["trip_start_time"], "20150102T000252-0500")
self.assertEqual(insertedTrips[1]["trip_end_time"], "20150102T000252-0500")
self.assertEqual(len(insertedSections), 2)
walkingSection = insertedSections[0]
walkingTrackPointArray = insertedSections[0]["track_points"]
self.assertEqual(walkingSection["section_start_time"], "20150102T000252-0500")
self.assertEqual(walkingSection["section_end_time"], "20150102T000253-0500")
self.assertEqual(walkingSection["duration"], 180631)
self.assertAlmostEqual(walkingSection["distance"], 1311.125, places=2)
self.assertEqual(len(walkingTrackPointArray), 7)
self.assertEqual(walkingTrackPointArray[0]["track_location"]["coordinates"], [-122.086945, 37.380866])
def testStoreSensedTrips(self):
fakeEmail = "*****@*****.**"
fakeUUID = User.fromEmail(fakeEmail).uuid
trip_array = json.load(open("emission/tests/data/sensed_trips.json"))
self.assertEqual(len(trip_array), 2)
tripManager.storeSensedTrips(fakeUUID, trip_array)
insertedTrips = [
trip for trip in get_trip_db().find({"user_id": fakeUUID})
]
# We load two sections for each user in the setup. Here we only want to
# look at sections that we added here. We distinguish between the two by looking
# to see whether the predicted mode exists
insertedSections = [
section for section in get_section_db().find({
"$and": [{
"user_id": fakeUUID
}, {
"predicted_mode": {
"$exists": False
}
}]
})
]
# insertedSections = [section["predicted_mode"] for section in get_section_db().find({"user_id": fakeUUID})]
self.assertEqual(len(insertedTrips), 2)
self.assertEqual(insertedTrips[0]["type"], "place")
self.assertEqual(insertedTrips[0]["trip_start_time"],
"20150101T000153-0500")
# self.assertEqual(insertedTrips[0]["trip_start_datetime"], datetime(2014,12,31,17,31,52))
self.assertEqual(insertedTrips[0]["trip_end_time"],
"20150102T000252-0500")
# self.assertEqual(insertedTrips[0]["trip_end_datetime"], datetime(2015,01,02,04,01,51))
startPlaceLocation = insertedTrips[0]["place"]["place_location"]
self.assertEqual(startPlaceLocation["coordinates"],
[-122.086945, 37.380866])
self.assertEqual(insertedTrips[1]["type"], "move")
self.assertEqual(insertedTrips[1]["trip_start_time"],
"20150102T000252-0500")
self.assertEqual(insertedTrips[1]["trip_end_time"],
"20150102T000252-0500")
self.assertEqual(len(insertedSections), 2)
walkingSection = insertedSections[0]
walkingTrackPointArray = insertedSections[0]["track_points"]
self.assertEqual(walkingSection["section_start_time"],
"20150102T000252-0500")
self.assertEqual(walkingSection["section_end_time"],
"20150102T000253-0500")
self.assertEqual(walkingSection["duration"], 180631)
self.assertAlmostEqual(walkingSection["distance"], 1311.125, places=2)
self.assertEqual(len(walkingTrackPointArray), 7)
self.assertEqual(
walkingTrackPointArray[0]["track_location"]["coordinates"],
[-122.086945, 37.380866])
def __getUUIDFromEmail__(userEmail):
user = User.fromEmail(userEmail)
if user is None:
return None
user_uuid = user.uuid
return user_uuid
def __getUUIDFromEmail__(userEmail):
user=User.fromEmail(userEmail)
if user is None:
return None
user_uuid=user.uuid
return user_uuid