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 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 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.ModesColl.remove()
self.assertEquals(self.ModesColl.find().count(), 0)
self.SectionsColl = get_section_db()
# self.SectionsColl.remove()
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/testCarbonFile")
# Let's make sure that the users are registered so that they have profiles
for userEmail in self.testUsers:
User.register(userEmail)
self.walkExpect = 1057.2524056424411
self.busExpect = 2162.668467546699
self.busCarbon = 267.0 / 1609
self.now = datetime.now()
self.dayago = self.now - timedelta(days=1)
self.weekago = self.now - timedelta(weeks=1)
emission.tests.common.updateSections(self)
def testRunBackgroundTasksForDay(self):
self.testUsers = [
"*****@*****.**", "*****@*****.**", "*****@*****.**",
"*****@*****.**", "*****@*****.**"
]
emission.tests.common.loadTable(self.serverName, "Stage_Modes",
"emission/tests/data/modes.json")
emission.tests.common.loadTable(self.serverName, "Stage_Sections",
"emission/tests/data/testCarbonFile")
# Let's make sure that the users are registered so that they have profiles
for userEmail in self.testUsers:
User.register(userEmail)
self.SectionsColl = get_section_db()
emission.tests.common.updateSections(self)
self.assertNotEqual(len(self.uuid_list), 0)
# Can access the zeroth element because we know that then length is greater than zero
# (see above)
test_uuid = self.uuid_list[0]
test_user = User.fromUUID(test_uuid)
self.assertNotIn('carbon_footprint', test_user.getProfile().keys())
data.runBackgroundTasks(test_user.uuid)
self.assertIn('carbon_footprint', test_user.getProfile().keys())
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(edb._get_current_db())
self.Profiles = get_profile_db()
self.assertEquals(self.Profiles.estimated_document_count(), 0)
emission.tests.common.loadTable(self.serverName, "Stage_Profiles",
"emission/tests/data/profiles.json")
self.assertEquals(self.Profiles.estimated_document_count(), 1)
# Let's make sure that the users are registered so that they have profiles
for userEmail in self.testUsers:
User.register(userEmail)
self.walkExpect = 1057.2524056424411
self.busExpect = 2162.668467546699
self.busCarbon = old_div(267.0, 1609)
self.now = datetime.now()
self.dayago = self.now - timedelta(days=1)
self.weekago = self.now - timedelta(weeks=1)
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 testChangeUpdateTs(self):
from datetime import datetime, timedelta
user = User.register('*****@*****.**')
self.assertTrue(User.isRegistered('*****@*****.**'))
user.changeUpdateTs(timedelta(days = -20))
self.assertEqual((datetime.now() - user.getUpdateTS()).days, 20)
def testChangeUpdateTs(self):
from datetime import datetime, timedelta
user = User.register('*****@*****.**')
self.assertTrue(User.isRegistered('*****@*****.**'))
user.changeUpdateTs(timedelta(days = -20))
self.assertEqual((datetime.now() - user.getUpdateTS()).days, 20)
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 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 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.ModesColl.remove()
self.assertEquals(self.ModesColl.find().count(), 0)
self.SectionsColl = get_section_db()
# self.SectionsColl.remove()
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/testCarbonFile")
# Let's make sure that the users are registered so that they have profiles
for userEmail in self.testUsers:
User.register(userEmail)
self.walkExpect = 1057.2524056424411
self.busExpect = 2162.668467546699
self.busCarbon = 267.0/1609
self.now = datetime.now()
self.dayago = self.now - timedelta(days=1)
self.weekago = self.now - timedelta(weeks = 1)
emission.tests.common.updateSections(self)
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 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 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 testSetClientSpecificFields(self):
user = User.register('*****@*****.**')
self.assertTrue(User.isRegistered('*****@*****.**'))
# Check that the field doesn't exist initially
self.assertTrue(user.getProfile().get('test_field', 'blank'), 'blank')
# Check that a simple value update works
user.setClientSpecificProfileFields({'test_field': 'something beautiful'})
self.assertTrue(user.getProfile().get('test_field', 'blank'), 'something beautiful')
# Check that a data structure update works
user.setClientSpecificProfileFields({'test_field': {'something': 'beautiful'}})
self.assertTrue(user.getProfile().get('test_field', 'blank'), {'something': 'beautiful'})
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 testSetClientSpecificFields(self):
user = User.register('*****@*****.**')
self.assertTrue(User.isRegistered('*****@*****.**'))
# Check that the field doesn't exist initially
self.assertTrue(user.getProfile().get('test_field', 'blank'), 'blank')
# Check that a simple value update works
user.setClientSpecificProfileFields({'test_field': 'something beautiful'})
self.assertTrue(user.getProfile().get('test_field', 'blank'), 'something beautiful')
# Check that a data structure update works
user.setClientSpecificProfileFields({'test_field': {'something': 'beautiful'}})
self.assertTrue(user.getProfile().get('test_field', 'blank'), {'something': 'beautiful'})
def getResult(user_uuid):
# This is in here, as opposed to the top level as recommended by the PEP
# because then we don't have to worry about loading bottle in the unit tests
from bottle import template
user = User.fromUUID(user_uuid)
currFootprint = getCarbonFootprint(user)
if currFootprint is None:
currFootprint = carbon.getFootprintCompare(user_uuid)
setCarbonFootprint(user, currFootprint)
(myModeShareCount, avgModeShareCount,
myModeShareDistance, avgModeShareDistance,
myModeCarbonFootprint, avgModeCarbonFootprint,
myModeCarbonFootprintNoLongMotorized, avgModeCarbonFootprintNoLongMotorized, # ignored
myOptimalCarbonFootprint, avgOptimalCarbonFootprint,
myOptimalCarbonFootprintNoLongMotorized, avgOptimalCarbonFootprintNoLongMotorized) = currFootprint
renderedTemplate = template("clients/data/result_template.html",
myModeShareCount = json.dumps(myModeShareCount),
avgModeShareCount = json.dumps(avgModeShareCount),
myModeShareDistance = json.dumps(myModeShareDistance),
avgModeShareDistance = json.dumps(avgModeShareDistance),
myModeCarbonFootprint = json.dumps(myModeCarbonFootprint),
avgModeCarbonFootprint = json.dumps(avgModeCarbonFootprint),
myOptimalCarbonFootprint = json.dumps(myOptimalCarbonFootprint),
avgOptimalCarbonFootprint = json.dumps(avgOptimalCarbonFootprint))
# logging.debug(renderedTemplate)
return renderedTemplate
def testUnsetStudyExists(self):
user = User.register('*****@*****.**')
user.setStudy('testclient')
self.assertEquals(userclient.countForStudy('testclient'), 1)
user.unsetStudy('testclient')
self.assertEquals(userclient.countForStudy('testclient'), 0)
def runBackgroundTasksForDay(user_uuid, today):
today_dt = datetime.combine(today, time.max)
user = User.fromUUID(user_uuid)
# carbon compare results is a tuple. Tuples are converted to arrays
# by mongodb
# In [44]: testUser.setScores(('a','b', 'c', 'd'), ('s', 't', 'u', 'v'))
# In [45]: testUser.getScore()
# Out[45]: ([u'a', u'b', u'c', u'd'], [u's', u't', u'u', u'v'])
weekago = today_dt - timedelta(days=7)
carbonCompareResults = carbon.getFootprintCompareForRange(user_uuid, weekago, today_dt)
setCarbonFootprint(user, carbonCompareResults)
(myModeShareCount, avgModeShareCount,
myModeShareDistance, avgModeShareDistance,
myModeCarbonFootprint, avgModeCarbonFootprint,
myModeCarbonFootprintNoLongMotorized, avgModeCarbonFootprintNoLongMotorized, # ignored
myOptimalCarbonFootprint, avgOptimalCarbonFootprint,
myOptimalCarbonFootprintNoLongMotorized, avgOptimalCarbonFootprintNoLongMotorized) = carbonCompareResults
# We only compute server stats in the background, because including them in
# the set call means that they may be invoked when the user makes a call and
# the cached value is None, which would potentially slow down user response time
msNow = systime.time()
stats.storeResultEntry(user_uuid, stats.STAT_MY_CARBON_FOOTPRINT, msNow, getCategorySum(myModeCarbonFootprint))
stats.storeResultEntry(user_uuid, stats.STAT_MY_CARBON_FOOTPRINT_NO_AIR, msNow, getCategorySum(myModeCarbonFootprintNoLongMotorized))
stats.storeResultEntry(user_uuid, stats.STAT_MY_OPTIMAL_FOOTPRINT, msNow, getCategorySum(myOptimalCarbonFootprint))
stats.storeResultEntry(user_uuid, stats.STAT_MY_OPTIMAL_FOOTPRINT_NO_AIR, msNow, getCategorySum(myOptimalCarbonFootprintNoLongMotorized))
stats.storeResultEntry(user_uuid, stats.STAT_MY_ALLDRIVE_FOOTPRINT, msNow, getCategorySum(myModeShareDistance) * (278.0/(1609 * 1000)))
stats.storeResultEntry(user_uuid, stats.STAT_MEAN_FOOTPRINT, msNow, getCategorySum(avgModeCarbonFootprint))
stats.storeResultEntry(user_uuid, stats.STAT_MEAN_FOOTPRINT_NO_AIR, msNow, getCategorySum(avgModeCarbonFootprintNoLongMotorized))
def getResult(user_uuid):
# This is in here, as opposed to the top level as recommended by the PEP
# because then we don't have to worry about loading bottle in the unit tests
from bottle import template
import base64
from dao.user import User
from dao.client import Client
user = User.fromUUID(user_uuid)
renderedTemplate = template(
"clients/choice/result_template.html",
variables=json.dumps({
'curr_view': getCurrView(user_uuid),
'uuid': str(user_uuid),
'client_key': Client("choice").getClientKey()
}),
gameResult=base64.b64encode(gamified.getResult(user_uuid)),
leaderboardResult=base64.b64encode(leaderboard.getResult(user_uuid)),
dataResult=base64.b64encode(data.getResult(user_uuid)),
commonTripsResult=base64.b64encode(commontrips.getResult(user_uuid)),
recommendationResult=base64.b64encode(
recommendation.getResult(user_uuid)))
return renderedTemplate
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 setupClientTest(self):
# At this point, the more important test is to execute the query and see
# how well it works
fakeEmail = "*****@*****.**"
client = Client("testclient")
client.update(createKey=False)
emission.tests.common.makeValid(client)
(resultPre,
resultReg) = client.preRegister("this_is_the_super_secret_id",
fakeEmail)
studyList = Client.getPendingClientRegs(fakeEmail)
self.assertEqual(studyList, ["testclient"])
user = User.register("*****@*****.**")
self.assertEqual(user.getFirstStudy(), 'testclient')
dummyPredModeMap = {'walking': 1.0}
dummySection = emission.tests.common.createDummySection(
startTime=datetime.now() - timedelta(seconds=60 * 60),
endTime=datetime.now(),
startLoc=[-122, 34],
endLoc=[-122, 35],
predictedMode=dummyPredModeMap)
return (user, dummySection, dummyPredModeMap)
def setUp(self):
import emission.tests.common
# 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())
user = User.register("*****@*****.**")
self.uuid = user.uuid
def setupClientTest(self):
# At this point, the more important test is to execute the query and see
# how well it works
fakeEmail = "*****@*****.**"
client = Client("testclient")
client.update(createKey = False)
emission.tests.common.makeValid(client)
(resultPre, resultReg) = client.preRegister("this_is_the_super_secret_id", fakeEmail)
studyList = Client.getPendingClientRegs(fakeEmail)
self.assertEqual(studyList, ["testclient"])
user = User.register("*****@*****.**")
self.assertEqual(user.getFirstStudy(), 'testclient')
dummyPredModeMap = {'walking': 1.0}
dummySection = emission.tests.common.createDummySection(
startTime = datetime.now() - timedelta(seconds = 60 * 60),
endTime = datetime.now(),
startLoc = [-122, 34],
endLoc = [-122, 35],
predictedMode = dummyPredModeMap)
return (user, dummySection, dummyPredModeMap)
def testClientSpecificSettersWithOverride(self):
fakeEmail = "*****@*****.**"
client = Client("testclient")
client.update(createKey = False)
common.makeValid(client)
(resultPre, resultReg) = client.preRegister("this_is_the_super_secret_id", fakeEmail)
studyList = Client.getPendingClientRegs(fakeEmail)
self.assertEqual(studyList, ["testclient"])
user = User.register("*****@*****.**")
self.assertEqual(user.getFirstStudy(), 'testclient')
dummyPredModeMap = {'walking': 1.0}
dummySection = common.createDummySection(startTime = datetime.now() - timedelta(seconds = 60 * 60),
endTime = datetime.now(),
startLoc = [-122, 34],
endLoc = [-122, 35],
predictedMode = dummyPredModeMap)
clientSetQuery = client.clientSpecificSetters(user.uuid, dummySection['_id'], dummyPredModeMap)
self.assertEqual(clientSetQuery, {'$set': {'test_auto_confirmed': {'mode': 1, 'prob': 1.0}}})
# Apply the change
get_section_db().update({'_id': dummySection['_id']}, clientSetQuery)
retrievedSection = get_section_db().find_one({'_id': dummySection['_id']})
self.assertEqual(retrievedSection['test_auto_confirmed']['mode'], 1)
def getScoreComponents(user_uuid, start, end):
# The score is based on the following components:
# - Percentage of trips classified. We are not auto-classifying high
# confidence trips, so don't need to handle those here
user = User.fromUUID(user_uuid)
pctClassified = common.getClassifiedRatio(user_uuid, start, end)
(myModeShareCount, avgModeShareCount, myModeShareDistance,
avgModeShareDistance, myModeCarbonFootprint, avgModeCarbonFootprint,
myModeCarbonFootprintNoLongMotorized,
avgModeCarbonFootprintNoLongMotorized, myOptimalCarbonFootprint,
avgOptimalCarbonFootprint, myOptimalCarbonFootprintNoLongMotorized,
avgOptimalCarbonFootprintNoLongMotorized
) = carbon.getFootprintCompareForRange(user.uuid, start, end)
carbon.delLongMotorizedModes(myModeShareDistance)
myAllDrive = carbon.getAllDrive(user.uuid, myModeShareDistance)
myCarbonFootprintSum = sum(myModeCarbonFootprintNoLongMotorized.values())
myOptimalFootprintSum = sum(
myOptimalCarbonFootprintNoLongMotorized.values())
logging.debug(
"myCarbonFootprintSum = %s, myOptimalFootprintSum = %s, myAllDrive = %s"
% (myCarbonFootprintSum, myOptimalFootprintSum, myAllDrive))
handleZero = lambda x, y: 0 if y == 0 else float(x) / y
components = [
pctClassified,
handleZero(myCarbonFootprintSum - myOptimalFootprintSum,
myOptimalFootprintSum),
handleZero(myAllDrive - myCarbonFootprintSum, myAllDrive),
handleZero(sb375DailyGoal - myCarbonFootprintSum, sb375DailyGoal)
]
return components
def setUp(self):
import emission.tests.common
# 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())
user = User.register("*****@*****.**")
self.uuid = user.uuid
def testUnsetStudyExists(self):
user = User.register('*****@*****.**')
user.setStudy('testclient')
self.assertEquals(userclient.countForStudy('testclient'), 1)
user.unsetStudy('testclient')
self.assertEquals(userclient.countForStudy('testclient'), 0)
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 getScoreComponents(user_uuid, start, end):
# The score is based on the following components:
# - Percentage of trips classified. We are not auto-classifying high
# confidence trips, so don't need to handle those here
user = User.fromUUID(user_uuid)
pctClassified = common.getClassifiedRatio(user_uuid, start, end)
(myModeShareCount, avgModeShareCount,
myModeShareDistance, avgModeShareDistance,
myModeCarbonFootprint, avgModeCarbonFootprint,
myModeCarbonFootprintNoLongMotorized, avgModeCarbonFootprintNoLongMotorized,
myOptimalCarbonFootprint, avgOptimalCarbonFootprint,
myOptimalCarbonFootprintNoLongMotorized, avgOptimalCarbonFootprintNoLongMotorized) = carbon.getFootprintCompareForRange(user.uuid, start, end)
carbon.delLongMotorizedModes(myModeShareDistance)
myAllDrive = carbon.getAllDrive(user.uuid, myModeShareDistance)
myCarbonFootprintSum = sum(myModeCarbonFootprintNoLongMotorized.values())
myOptimalFootprintSum = sum(myOptimalCarbonFootprintNoLongMotorized.values())
logging.debug("myCarbonFootprintSum = %s, myOptimalFootprintSum = %s, myAllDrive = %s" %
(myCarbonFootprintSum, myOptimalFootprintSum, myAllDrive))
handleZero = lambda x, y: 0 if y == 0 else float(x)/y
components = [pctClassified,
handleZero(myCarbonFootprintSum - myOptimalFootprintSum, myOptimalFootprintSum),
handleZero(myAllDrive - myCarbonFootprintSum, myAllDrive),
handleZero(sb375DailyGoal - myCarbonFootprintSum, sb375DailyGoal)]
return components
def testClientSpecificSettersWithOverride(self):
fakeEmail = "*****@*****.**"
client = Client("testclient")
client.update(createKey = False)
common.makeValid(client)
(resultPre, resultReg) = client.preRegister("this_is_the_super_secret_id", fakeEmail)
studyList = Client.getPendingClientRegs(fakeEmail)
self.assertEqual(studyList, ["testclient"])
user = User.register("*****@*****.**")
self.assertEqual(user.getFirstStudy(), 'testclient')
dummyPredModeMap = {'walking': 1.0}
dummySection = common.createDummySection(startTime = datetime.now() - timedelta(seconds = 60 * 60),
endTime = datetime.now(),
startLoc = [-122, 34],
endLoc = [-122, 35],
predictedMode = dummyPredModeMap)
clientSetQuery = client.clientSpecificSetters(user.uuid, dummySection['_id'], dummyPredModeMap)
self.assertEqual(clientSetQuery, {'$set': {'test_auto_confirmed': {'mode': 1, 'prob': 1.0}}})
# Apply the change
get_section_db().update({'_id': dummySection['_id']}, clientSetQuery)
retrievedSection = get_section_db().find_one({'_id': dummySection['_id']})
self.assertEqual(retrievedSection['test_auto_confirmed']['mode'], 1)
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 testMergeDict(self):
dict1 = {'a': 'a1', 'b': 'b1', 'c': 'c1'}
dict2 = {'d': 'd2', 'b': 'b2', 'c': 'c2'}
mergedDict = User.mergeDicts(dict1, dict2)
self.assertEqual(len(mergedDict), 4)
self.assertEqual(mergedDict['a'], 'a1')
self.assertEqual(mergedDict, {'a': 'a1', 'b': 'b2', 'c': 'c2', 'd': 'd2'})
def updateUserProfile():
logging.debug("Called updateUserProfile")
user_uuid = getUUID(request)
user = User.fromUUID(user_uuid)
new_fields = request.json['update_doc']
to_return = user.update(new_fields)
logging.debug("Successfully updated profile for user %s" % user_uuid)
return {"update": True}
def getCurrView(uuid):
user = User.fromUUID(uuid)
profile = user.getProfile()
if profile is None:
logging.debug("profile is None, returning data")
return "data"
logging.debug("profile.get('curr_view', 'dummy') is %s" % profile.get("curr_view", "data"))
return profile.get("curr_view", "data")
def testCarbonFootprintStore(self):
user = User.fromUUID(self.uuid)
# Tuple of JSON objects, similar to the real footprint
dummyCarbonFootprint = ({'myModeShareCount': 10}, {'avgModeShareCount': 20})
self.assertEquals(data.getCarbonFootprint(user), None)
data.setCarbonFootprint(user, dummyCarbonFootprint)
# recall that pymongo converts tuples to lists somewhere down the line
self.assertEquals(data.getCarbonFootprint(user), list(dummyCarbonFootprint))
def updateUserProfile():
logging.debug("Called updateUserProfile")
user_uuid = getUUID(request)
user = User.fromUUID(user_uuid)
new_fields = request.json['update_doc']
to_return = user.update(new_fields)
logging.debug("Successfully updated profile for user %s" % user_uuid)
return {"update": True}
def getUserClient(user_uuid):
study = User.fromUUID(user_uuid).getFirstStudy()
if study != None:
client = Client(study)
return client
else:
# User is not part of any study, so no additional filtering is needed
return None
def testMergeDict(self):
dict1 = {'a': 'a1', 'b': 'b1', 'c': 'c1'}
dict2 = {'d': 'd2', 'b': 'b2', 'c': 'c2'}
mergedDict = User.mergeDicts(dict1, dict2)
self.assertEqual(len(mergedDict), 4)
self.assertEqual(mergedDict['a'], 'a1')
self.assertEqual(mergedDict, {'a': 'a1', 'b': 'b2', 'c': 'c2', 'd': 'd2'})
def getUserClient(user_uuid):
study = User.fromUUID(user_uuid).getFirstStudy()
if study != None:
client = Client(study)
return client
else:
# User is not part of any study, so no additional filtering is needed
return None
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 getCurrView(uuid):
user = User.fromUUID(uuid)
profile = user.getProfile()
if profile is None:
logging.debug("profile is None, returning data")
return "data"
logging.debug("profile.get('curr_view', 'dummy') is %s" %
profile.get("curr_view", "data"))
return profile.get("curr_view", "data")
def setUp(self):
# 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())
user = User.register("*****@*****.**")
self.uuid = user.uuid
self.serverName = "localhost"
self.now = datetime.now()
self.dayago = self.now - timedelta(days=1)
self.weekago = self.now - timedelta(weeks=1)
def setUp(self):
# 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())
user = User.register("*****@*****.**")
self.uuid = user.uuid
self.serverName = "localhost"
self.now = datetime.now()
self.dayago = self.now - timedelta(days=1)
self.weekago = self.now - timedelta(weeks = 1)
def getResult(user_uuid):
# This is in here, as opposed to the top level as recommended by the PEP
# because then we don't have to worry about loading bottle in the unit tests
from bottle import template
(prevScore, currScore) = getStoredScore(User.fromUUID(user_uuid))
(level, sublevel) = getLevel(currScore)
otherCurrScoreList = []
for user_uuid_dict in get_uuid_db().find({}, {'uuid': 1, '_id': 0}):
(currPrevScore, currCurrScore) = getStoredScore(User.fromUUID(user_uuid_dict['uuid']))
otherCurrScoreList.append(currCurrScore)
otherCurrScoreList.sort()
renderedTemplate = template("clients/leaderboard/result_template.html",
level_picture_filename = getFileName(level, sublevel),
prevScore = prevScore,
currScore = currScore,
otherCurrScoreList = otherCurrScoreList)
return renderedTemplate
def testRegisterStudyUser(self):
client = Client("testclient")
client.update(createKey = False)
common.makeValid(client)
(resultPre, resultReg) = client.preRegister("this_is_the_super_secret_id", "*****@*****.**")
self.assertEqual(resultPre, 1)
self.assertEqual(resultReg, 0)
user = User.register('*****@*****.**')
self.assertEquals(user.getStudy(), ['testclient'])
def testCountForStudy(self):
client = Client("testclient")
client.update(createKey = False)
common.makeValid(client)
(resultPre, resultReg) = client.preRegister("this_is_the_super_secret_id", "*****@*****.**")
self.assertEqual(resultPre, 1)
self.assertEqual(resultReg, 0)
user = User.register('*****@*****.**')
self.assertEquals(userclient.countForStudy('testclient'), 1)
def testGetSettingsCustomUser(self):
client = Client("testclient")
client.update(createKey = False)
common.makeValid(client)
(resultPre, resultReg) = client.preRegister("this_is_the_super_secret_id", "*****@*****.**")
self.assertEqual(resultPre, 1)
self.assertEqual(resultReg, 0)
user = User.register('*****@*****.**')
self.assertRegexpMatches(user.getSettings()['result_url'], ".*/test/test/test")
def testGetSettingsCustomUser(self):
client = Client("testclient")
client.update(createKey = False)
common.makeValid(client)
(resultPre, resultReg) = client.preRegister("this_is_the_super_secret_id", "*****@*****.**")
self.assertEqual(resultPre, 1)
self.assertEqual(resultReg, 0)
user = User.register('*****@*****.**')
self.assertRegexpMatches(user.getSettings()['result_url'], ".*/test/test/test")
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 createUserProfile():
try:
logging.debug("Called createUserProfile")
userEmail = enaa._getEmail(request, auth_method)
logging.debug("userEmail = %s" % userEmail)
user = User.register(userEmail)
logging.debug("Looked up user = %s" % user)
logging.debug("Returning result %s" % {'uuid': str(user.uuid)})
return {'uuid': str(user.uuid)}
except ValueError as e:
traceback.print_exc()
abort(403, e.message)
def createUserProfile():
try:
logging.debug("Called createUserProfile")
userEmail = enaa._getEmail(request, auth_method)
logging.debug("userEmail = %s" % userEmail)
user = User.register(userEmail)
logging.debug("Looked up user = %s" % user)
logging.debug("Returning result %s" % {'uuid': str(user.uuid)})
return {'uuid': str(user.uuid)}
except ValueError as e:
traceback.print_exc()
abort(403, e.message)
def testRunBackgroundTasksForDay(self):
self.testUsers = ["*****@*****.**", "*****@*****.**", "*****@*****.**",
"*****@*****.**", "*****@*****.**"]
emission.tests.common.loadTable(self.serverName, "Stage_Modes", "emission/tests/data/modes.json")
emission.tests.common.loadTable(self.serverName, "Stage_Sections", "emission/tests/data/testCarbonFile")
# Let's make sure that the users are registered so that they have profiles
for userEmail in self.testUsers:
User.register(userEmail)
self.SectionsColl = get_section_db()
emission.tests.common.updateSections(self)
self.assertNotEqual(len(self.uuid_list), 0)
# Can access the zeroth element because we know that then length is greater than zero
# (see above)
test_uuid = self.uuid_list[0]
test_user = User.fromUUID(test_uuid)
self.assertNotIn('carbon_footprint', test_user.getProfile().keys())
data.runBackgroundTasks(test_user.uuid)
self.assertIn('carbon_footprint', test_user.getProfile().keys())
def testPreRegisterExistingUser(self):
user = User.register("*****@*****.**")
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)
self.assertEqual(user.getStudy(), ['testclient'])
pendingRegs = Client.getPendingClientRegs("*****@*****.**")
self.assertEqual(pendingRegs, [])
