def test_removeClassFromStudent(self):
print('Running removeClassFromStudent test case')
userRole = 'admin'
email = '*****@*****.**'
classCode = 'f77668db-fb9d-4fd6-81f1-026784d6cc9b'
classCode2 = 'e00045db-fb9d-4fd6-81f1-026784d6cc9b'
res = ResponseCreation.ControllerResponse()
# Put user and class data into DB
usersTable = db.getTable('users', dynamodb)
userJsonData = {'email': email, 'classCodes': [classCode, classCode2]}
db.putItem(userJsonData, usersTable)
# Check test data was successfully placed into DB
jsonData = {'Key': {'email': email}}
response = db.getItem(jsonData, usersTable)
self.assertIsNotNone(response.get('Item'))
self.assertEqual(response.get('Item').get('email'), email)
class_ctrl.removeClassFromStudent(dynamodb, res, email, classCode2)
# Check that the classCode was removed from the student
jsonData = {'Key': {'email': email}}
response = db.getItem(jsonData, usersTable)
self.assertIsNotNone(response.get('Item'))
cc = response.get('Item').get('classCodes')
self.assertFalse(classCode2 in cc)
self.assertTrue(classCode in cc)
def test_removeStudentFromClass_len_zero(self):
print(
'Running removeStudentFromClass students length is zero test case')
userRole = 'admin'
email = '*****@*****.**'
classCode = 'f77998db-fb9d-4fd6-81f1-026784d6cc9b'
res = ResponseCreation.ControllerResponse()
#Put user and class data into DB
classesTable = db.getTable('classes', dynamodb)
classJsonData = {'code': classCode, 'students': [email]}
db.putItem(classJsonData, classesTable)
#Check test data was successfully placed into DB
jsonData = {'Key': {'code': classCode}}
response = db.getItem(jsonData, classesTable)
self.assertIsNotNone(response.get('Item'))
self.assertEqual(response.get('Item').get('code'), classCode)
class_ctrl.removeStudentFromClass(dynamodb, res, email, classCode)
#check that the attribute was removed from the class
jsonData = {'Key': {'code': classCode}}
response = db.getItem(jsonData, classesTable)
self.assertIsNotNone(response.get('Item'))
self.assertIsNone(response.get('Item').get('students'))
def test_changeUserRole_fail(self):
print('Running test_changeUserRole_fail test')
usersTable = db.getTable('users', dynamodb)
request = {
'Key': {
'email': '*****@*****.**'
},
'ProjectExpression': 'userRole'
}
response = db.getItem(request, usersTable)
self.assertEqual(response['Item']['userRole'], 'student')
badJsonData = {'email': '*****@*****.**', 'userRole': 'boss'}
# change user role to not defined role
usr.changeUserRole(badJsonData, dynamodb, adminRole='admin')
#role remains same as it was before failed attempt
response = db.getItem(request, usersTable)
self.assertEqual(response['Item']['userRole'], 'student')
badJsonData = {'email': '*****@*****.**', 'userRole': 'student'}
# try to change a user role of a non-existent user
response = usr.changeUserRole(badJsonData, dynamodb, adminRole='admin')
self.assertIsNone(response.payload.get('success'))
def test_removeClassFromStudent_len_zero(self):
print(
'Running removeClassFromStudent students length is zero test case')
userRole = 'admin'
email = '*****@*****.**'
classCode = 'f84138db-fb9d-4fd6-81f1-026784d6cc9b'
res = ResponseCreation.ControllerResponse()
#Put user and class data into DB
usersTable = db.getTable('users', dynamodb)
userJsonData = {'email': email, 'classCodes': [classCode]}
db.putItem(userJsonData, usersTable)
# Check test data was successfully placed into DB
jsonData = {'Key': {'email': email}}
response = db.getItem(jsonData, usersTable)
self.assertIsNotNone(response.get('Item'))
self.assertEqual(response.get('Item').get('email'), email)
class_ctrl.removeClassFromStudent(dynamodb, res, email, classCode)
# Check that the attribute was removed from the student
jsonData = {'Key': {'email': email}}
response = db.getItem(jsonData, usersTable)
self.assertIsNotNone(response.get('Item'))
self.assertIsNone(response.get('Item').get('classCodes'))
def test_removeStudentFromClasss(self):
print('Running removeStudentFromClass test case')
userRole = 'admin'
email1 = '[email protected]'
email2 = '[email protected]'
classCode = 'f77668db-fb9d-4fd6-81f1-026784d6cc9b'
res = ResponseCreation.ControllerResponse()
#Put user and class data into DB
classesTable = db.getTable('classes', dynamodb)
classJsonData = {'code': classCode, 'students': [email1, email2]}
db.putItem(classJsonData, classesTable)
#Check test data was successfully placed into DB
jsonData = {'Key': {'code': classCode}}
response = db.getItem(jsonData, classesTable)
self.assertIsNotNone(response.get('Item'))
self.assertEqual(response.get('Item').get('code'), classCode)
class_ctrl.removeStudentFromClass(dynamodb, res, email1, classCode)
#check that the student was removed from the class
jsonData = {'Key': {'code': classCode}}
response = db.getItem(jsonData, classesTable)
self.assertIsNotNone(response.get('Item'))
stu = response.get('Item').get('students')
self.assertFalse(email1 in stu)
self.assertTrue(email2 in stu)
def test_removeStudent(self):
print('Running removeStudent test case')
userRole = 'admin'
email = '*****@*****.**'
classCode = 'f24613dc-f09d-4fd6-81f1-026784d6cc9b'
#Put user and class data into DB
usersTable = db.getTable('users', dynamodb)
classesTable = db.getTable('classes', dynamodb)
userJsonData = {'email': email, 'classCodes': [classCode]}
classJsonData = {'code': classCode, 'students': [email]}
db.putItem(userJsonData, usersTable)
db.putItem(classJsonData, classesTable)
#Check test data was successfully placed into DB
jsonData = {'Key': {'email': email}}
response = db.getItem(jsonData, usersTable)
self.assertIsNotNone(response.get('Item'))
self.assertEqual(response.get('Item').get('email'), email)
jsonData = {'Key': {'code': classCode}}
response = db.getItem(jsonData, classesTable)
self.assertIsNotNone(response.get('Item'))
self.assertEqual(response.get('Item').get('code'), classCode)
#Test removal
jsonData = {'email': email, 'classCode': classCode}
res = class_ctrl.removeStudent(dynamodb, jsonData, userRole=userRole)
self.assertFalse(res.hasErrors())
def test_createMultipleClasses(self):
print('Running createMultipleClasses test case')
classData = {
'title': 'ENG',
'department': 'arts',
'section': '12',
'description': 'english'
}
classData2 = {
'title': 'PE',
'department': 'science',
'section': '1',
'description': 'physical education'
}
email = '*****@*****.**'
userRole = 'teacher'
class_ctrl.createClass(dynamodb, classData, email, userRole)
class_ctrl.createClass(dynamodb, classData2, email, userRole)
# check that teaching list was added to user
classesTable = db.getTable('classes', dynamodb)
usersTable = db.getTable('users', dynamodb)
data = {'Key': {'email': email}}
teacher = db.getItem(data, usersTable)
self.assertTrue('Item' in teacher.keys())
self.assertTrue('teaching' in teacher['Item'])
teachingSet = teacher['Item']['teaching']
self.assertEqual(len(teachingSet), 2)
# check that classes were created in classes table
class1Found = False
class2Found = False
for classCode in teachingSet:
data = {'Key': {'code': classCode}}
classItem = db.getItem(data, classesTable)
self.assertTrue('Item' in classItem.keys())
if (classItem['Item']['title'] == 'ENG'
and classItem['Item']['department'] == 'arts'
and classItem['Item']['classSection'] == '12'
and classItem['Item']['description'] == 'english'):
class1Found = True
elif (classItem['Item']['title'] == 'PE'
and classItem['Item']['department'] == 'science'
and classItem['Item']['classSection'] == '1' and
classItem['Item']['description'] == 'physical education'):
class2Found = True
self.assertTrue(class1Found)
self.assertTrue(class2Found)
def test_undoClassCodeRemoval(self):
print('Running undoClassCodeRemoval test case')
email = '*****@*****.**'
classCode = 'f99998db-fb9d-4fd6-81f1-026784d6cc9b'
classCode2 = 'f00000db-fb9d-4fd6-81f1-026784d6cc9b'
#Put user and class data into DB
usersTable = db.getTable('users', dynamodb)
### to simulate class already removed from student ###
userJsonData = {'email': email}
db.putItem(userJsonData, usersTable)
#Check test data was successfully placed into DB
jsonData = {'Key': {'email': email}}
response = db.getItem(jsonData, usersTable)
self.assertIsNotNone(response.get('Item'))
self.assertEqual(response.get('Item').get('email'), email)
#Test simulated error in undoClassCodeRemoval email
class_ctrl.undoClassCodeRemoval(dynamodb, email, classCode)
#check class was place back into student's classCodes
jsonData = {'Key': {'email': email}}
response = db.getItem(jsonData, usersTable)
self.assertIsNotNone(response.get('Item'))
classCodes = response.get('Item').get('classCodes')
self.assertTrue(classCode in classCodes)
#### add classCode back to a list that when removed will still have elements ###
userJsonData = {
'email': email,
'classCodes': set([classCode, classCode2])
}
db.putItem(userJsonData, usersTable)
#Check test data was successfully placed into DB
jsonData = {'Key': {'email': email}}
response = db.getItem(jsonData, usersTable)
self.assertIsNotNone(response.get('Item'))
self.assertEqual(response.get('Item').get('email'), email)
#Test simulated error in undoClassCodeRemoval email
class_ctrl.undoClassCodeRemoval(dynamodb, email, classCode2)
#check class was place back into student's classCodes
jsonData = {'Key': {'email': email}}
response = db.getItem(jsonData, usersTable)
self.assertIsNotNone(response.get('Item'))
classCodes = response.get('Item').get('classCodes')
self.assertTrue(classCode in classCodes)
self.assertTrue(classCode2 in classCodes)
def test_updateClassDetails(self):
print('Running updateClassDetails test')
classesTable = db.getTable('classes', dynamodb)
usersTable = db.getTable('users', dynamodb)
email = '*****@*****.**'
userRole = 'teacher'
# put data into db first
beforeUserData = {'email': email, 'teaching': ['before update code']}
beforeClassData = {
'title': 'before update title',
'department': 'before update department',
'description': 'before update description',
'classSection': 'before update section',
'code': 'before update code'
}
db.putItem(beforeClassData, classesTable)
db.putItem(beforeUserData, usersTable)
# check item was placed successfully
code = {'Key': {'code': 'before update code'}}
c = db.getItem(code, classesTable)
self.assertTrue('Item' in c.keys())
e = {'Key': {'email': email}}
user = db.getItem(e, usersTable)
self.assertTrue('Item' in user.keys())
# update class details
afterData = {
'title': 'after update title',
'department': 'after update department',
'description': 'after update description',
'section': 'after update section',
'code': 'before update code'
}
response = class_ctrl.updateClassDetails(afterData, dynamodb, email,
userRole)
self.assertEqual(response.payload,
{'Success': 'Class Details Updated'})
c = db.getItem(code, classesTable)
self.assertTrue('Item' in c.keys())
self.assertEqual(c['Item']['title'], 'after update title')
self.assertEqual(c['Item']['department'], 'after update department')
self.assertEqual(c['Item']['classSection'], 'after update section')
self.assertEqual(c['Item']['description'], 'after update description')
def getClassCodesFromUser(dynamoDBInstance, email=None):
classCodes = set()
if email is None: # pragma: no cover
email = g.authenticatedUser['email']
usersTable = dbUtils.getTable('users', dynamoDBInstance)
if usersTable is None:
MentiiLogging.getLogger().error(
'Unable to get users table in getClassCodesFromUser')
else:
#An active class list is the list of class codes that
# a user has in the user table.
request = {
"Key": {
"email": email
},
"ProjectionExpression": "classCodes"
}
res = dbUtils.getItem(request, usersTable)
#Get the class codes for the user.
if res is None or 'Item' not in res or 'classCodes' not in res['Item']:
MentiiLogging.getLogger().error(
'Unable to get user data in getClassCodesFromUser')
else:
classCodes = res['Item']['classCodes']
return classCodes
def test_getItem_fail(self):
print("Running getItem_fail fail test case")
self.assertIsNotNone(self.table)
self.assertEqual(self.table.table_status, "ACTIVE")
jsonData = '{\
"Key": {"email":"*****@*****.**"},\
"ProjectionExpression": "password"\
}'
response = db.getItem(jsonData, self.table)
self.assertIsNone(response.get("Item"))
def test_getItem_string(self):
print("Running getItem_string test")
self.assertIsNotNone(self.table)
self.assertEqual(self.table.table_status, "ACTIVE")
jsonData = '{\
"Key": {"email":"*****@*****.**"},\
"ProjectionExpression": "password"\
}'
response = db.getItem(jsonData, self.table)
self.assertIsNotNone(response.get("Item"))
self.assertEqual(response.get("Item").get("password"), "iameight2")
def getBook(bookId, dynamoDBInstance):
book = None
booksTable = dbUtils.getTable('books', dynamoDBInstance)
if booksTable is None:
MentiiLogging.getLogger().error('Could not get book table')
else:
bookQuery = {'Key': {'bookId': bookId}}
res = dbUtils.getItem(bookQuery, booksTable)
if res is not None and 'Item' in res.keys():
book = res['Item']
else:
MentiiLogging.getLogger().warning(
'Could not get an item from the books table')
return book
def test_getItem_json(self):
print("Running getItem_json test")
self.assertIsNotNone(self.table)
self.assertEqual(self.table.table_status, "ACTIVE")
jsonData = {
'Key': {
'email': '*****@*****.**'
},
}
response = db.getItem(jsonData, self.table)
self.assertIsNotNone(response.get("Item"))
self.assertEqual(response.get("Item").get("email"), "*****@*****.**")
def test_createClass(self):
print('Running creatClass test case')
classData = {
'title': 'PSY',
'department': 'science',
'section': '25',
'description': 'How our brain works'
}
email = '*****@*****.**'
userRole = 'teacher'
response = class_ctrl.createClass(dynamodb, classData, email, userRole)
# check response message
self.assertEqual(response.payload, {'Success': 'Class Created'})
# check that teaching set was added to user
classesTable = db.getTable('classes', dynamodb)
usersTable = db.getTable('users', dynamodb)
data = {'Key': {'email': email}}
teacher = db.getItem(data, usersTable)
self.assertTrue('Item' in teacher.keys())
self.assertTrue('teaching' in teacher['Item'])
teachingList = list(teacher['Item']['teaching'])
# check that class was created in classes table
classCode = str(teachingList[0])
data = {'Key': {'code': classCode}}
classItem = db.getItem(data, classesTable)
self.assertTrue('Item' in classItem.keys())
self.assertEqual(classItem['Item']['title'], 'PSY')
self.assertEqual(classItem['Item']['department'], 'science')
self.assertEqual(classItem['Item']['classSection'], '25')
self.assertEqual(classItem['Item']['description'],
'How our brain works')
def getUserByEmail(email, dbInstance):
user = None
table = dbUtils.getTable('users', dbInstance)
if table is None:
MentiiLogging.getLogger().error('Unable to get table users in getUserByEmail')
else:
key = {'Key' : {'email': email}}
result = dbUtils.getItem(key, table)
if result is None:
MentiiLogging.getLogger().error('Unable to get the user with email: ' + email + ' in getUserByEmail ')
elif 'Item' in result.keys():
user = result['Item']
return user
def getClassByCode(classCode, dynamoDBInstance):
classData = None
classTable = dbUtils.getTable('classes', dynamoDBInstance)
if not classTable:
MentiiLogging.getLogger().error(
'Unable to access class table in getClassByCode')
else:
request = {'Key': {'code': classCode}}
res = dbUtils.getItem(request, classTable)
if not res or 'Item' not in res:
MentiiLogging.getLogger().error(
'Unable to load class data in getClassByCode')
else:
classData = res['Item']
return classData
def test_changeUserRole(self):
print('Running test_changeUserRole test')
usersTable = db.getTable('users', dynamodb)
request = {
'Key': {
'email': '*****@*****.**'
},
'ProjectExpression': 'userRole'
}
# check that user is a student
response = db.getItem(request, usersTable)
self.assertEqual(response['Item']['userRole'], 'student')
# change user role to teacher
jsonData = {'email': '*****@*****.**', 'userRole': 'teacher'}
usr.changeUserRole(jsonData, dynamodb, adminRole='admin')
response = db.getItem(request, usersTable)
self.assertEqual(response['Item']['userRole'], 'teacher')
# change user role to admin
jsonData = {'email': '*****@*****.**', 'userRole': 'admin'}
usr.changeUserRole(jsonData, dynamodb, adminRole='admin')
response = db.getItem(request, usersTable)
self.assertEqual(response['Item']['userRole'], 'admin')
# change user role back to student
jsonData = {'email': '*****@*****.**', 'userRole': 'student'}
usr.changeUserRole(jsonData, dynamodb, adminRole='admin')
response = db.getItem(request, usersTable)
self.assertEqual(response['Item']['userRole'], 'student')
def getTaughtClassCodesFromUser(dynamoDBInstance, email=None):
classCodes = None
if email is None: # pragma: no cover
email = g.authenticatedUser['email']
usersTable = dbUtils.getTable('users', dynamoDBInstance)
if usersTable is None:
MentiiLogging.getLogger().error(
'Unable to get users table in getTaughtClassCodesFromUser')
else:
#An active class list is the list of class codes that
# a user has in the user table.
request = {'Key': {'email': email}, 'ProjectionExpression': 'teaching'}
res = dbUtils.getItem(request, usersTable)
#Get the class codes for the user.
if res is not None and 'Item' in res:
classCodes = res['Item'].get('teaching', [])
return classCodes
def getRole(userEmail, dynamoDBInstance):
'''
Returns the role of the user whose email is pased. If we are unable to get
this information from the DB the role None is returned. Calling code must
grant only student permissions in this case.
'''
userRole = None
table = dbUtils.getTable('users', dynamoDBInstance)
if table is None:
MentiiLogging.getLogger().error('Could not get user table in getUserRole')
else:
request = {"Key" : {"email": userEmail}, "ProjectionExpression": "userRole"}
res = dbUtils.getItem(request, table)
if res is None or 'Item' not in res:
MentiiLogging.getLogger().error('Could not get role for user ' + userEmail)
else:
userRole = res['Item']['userRole']
return userRole
def getTaughtClassList(dynamoDBInstance, email=None):
response = ControllerResponse()
if email is None: # pragma: no cover
email = g.authenticatedUser['email']
usersTable = dbUtils.getTable('users', dynamoDBInstance)
classTable = dbUtils.getTable('classes', dynamoDBInstance)
if usersTable is None or classTable is None:
response.addError('Get Taught Class List Failed',
'Unable to access users and/or classes')
else:
classes = []
classCodes = getTaughtClassCodesFromUser(dynamoDBInstance, email)
if classCodes is not None:
for code in classCodes:
request = {'Key': {'code': code}}
res = dbUtils.getItem(request, classTable)
if res is not None and 'Item' in res:
classes.append(res['Item'])
response.addToPayload('classes', classes)
return response
def getBookInfoFromActivity(classId, activityTitle, dynamoDBInstance):
classItem = {}
bookId = ''
chapterTitle = ''
sectionTitle = ''
classTable = dbUtils.getTable('classes', dynamoDBInstance)
if classTable is None:
MentiiLogging.getLogger().warning('Could not get the class table')
else:
classQuery = {'Key': {'code': classId}}
res = dbUtils.getItem(classQuery, classTable)
if res is not None and 'Item' in res.keys():
classItem = res['Item']
for activity in classItem.get('activities', []):
if activity.get('title', '') == activityTitle:
bookId = activity.get('bookId', '')
chapterTitle = activity.get('chapterTitle', '')
sectionTitle = activity.get('sectionTitle', '')
break #Only get the first activity with this title
return (bookId, chapterTitle, sectionTitle)
def test_createClassWrongRole(self):
print('Running creatClassWrongRole test case')
classData = {
'title': 'LING',
'department': 'science',
'section': '44',
'description': 'Linguistics'
}
email = '*****@*****.**'
userRole = 'student'
response = class_ctrl.createClass(dynamodb, classData, email, userRole)
# check response message
self.assertTrue(response.hasErrors)
#check that user does not have teaching list
usersTable = db.getTable('users', dynamodb)
data = {'Key': {'email': email}}
teacher = db.getItem(data, usersTable)
self.assertTrue('Item' in teacher.keys())
self.assertFalse('teaching' in teacher['Item'])
def test_updateClassDetails_len_zero(self):
print('Running updateClassDetails length zero test')
classesTable = db.getTable('classes', dynamodb)
usersTable = db.getTable('users', dynamodb)
email = '*****@*****.**'
userRole = 'admin'
# put data into db first
beforeUserData = {'email': email, 'teaching': ['before update code']}
beforeClassData = {
'title': 'before update title',
'department': 'before update department',
'description': 'before update description',
'classSection': 'before update section',
'code': 'before update code'
}
db.putItem(beforeClassData, classesTable)
db.putItem(beforeUserData, usersTable)
# check item was placed successfully
code = {'Key': {'code': 'before update code'}}
c = db.getItem(code, classesTable)
self.assertTrue('Item' in c.keys())
e = {'Key': {'email': email}}
user = db.getItem(e, usersTable)
self.assertTrue('Item' in user.keys())
##### update class details removing both optional attributes
afterData = {
'title': 'after update title',
'department': '',
'description': 'after update description',
'section': '',
'code': 'before update code'
}
response = class_ctrl.updateClassDetails(afterData, dynamodb, email,
userRole)
self.assertEqual(response.payload,
{'Success': 'Class Details Updated'})
c = db.getItem(code, classesTable)
self.assertTrue('Item' in c.keys())
self.assertFalse('department' in c['Item'])
self.assertFalse('classSection' in c['Item'])
##### update class details removing only one of the optional attributes
beforeData = {
'title': 'before update title',
'department': 'asdf',
'description': 'before update description',
'classSection': 'lkjh',
'code': 'before update code'
}
db.putItem(beforeData, classesTable)
afterData = {
'title': 'after update title',
'department': 'asdf',
'description': 'after update description',
'section': '',
'code': 'before update code'
}
response = class_ctrl.updateClassDetails(afterData, dynamodb, email,
userRole)
self.assertEqual(response.payload,
{'Success': 'Class Details Updated'})
c = db.getItem(code, classesTable)
self.assertTrue('Item' in c.keys())
self.assertFalse('classSection' in c['Item'])
self.assertEqual(c['Item']['department'], 'asdf')
afterData = {
'title': 'after update title',
'department': '',
'description': 'after update description',
'section': 'lkjh',
'code': 'before update code'
}
response = class_ctrl.updateClassDetails(afterData, dynamodb, email,
userRole)
self.assertEqual(response.payload,
{'Success': 'Class Details Updated'})
c = db.getItem(code, classesTable)
self.assertTrue('Item' in c.keys())
self.assertFalse('department' in c['Item'])
self.assertEqual(c['Item']['classSection'], 'lkjh')
def test_removeStudent_data_fail(self):
print('Running removeStudent data fail test case')
userRole = 'admin'
email = '*****@*****.**'
classCode = 'f15708db-fb9d-4fd6-81f1-026784d6cc9b'
#Put user and class data into DB
usersTable = db.getTable('users', dynamodb)
classesTable = db.getTable('classes', dynamodb)
userJsonData = {'email': email, 'classCodes': [classCode]}
classJsonData = {'code': classCode, 'students': [email]}
db.putItem(userJsonData, usersTable)
db.putItem(classJsonData, classesTable)
#Check test data was successfully placed into DB
jsonData = {'Key': {'email': email}}
response = db.getItem(jsonData, usersTable)
self.assertIsNotNone(response.get('Item'))
self.assertEqual(response.get('Item').get('email'), email)
jsonData = {'Key': {'code': classCode}}
response = db.getItem(jsonData, classesTable)
self.assertIsNotNone(response.get('Item'))
self.assertEqual(response.get('Item').get('code'), classCode)
#Test bad class code
jsonData = {
'email': email,
'classCode': 'f24abcdc-f09d-4fd6-81f1-026784d6cc9b'
}
res = class_ctrl.removeStudent(dynamodb, jsonData, userRole=userRole)
self.assertTrue(res.hasErrors())
self.assertEqual(
res.errors[0], {
'message': 'Class not found',
'title': 'Failed to remove class from student'
})
#check student wasn't removed from class
jsonData = {'Key': {'code': classCode}}
response = db.getItem(jsonData, classesTable)
self.assertIsNotNone(response.get('Item'))
students = response.get('Item').get('students')
self.assertTrue(email in students)
#Test bad email
jsonData = {'email': '*****@*****.**', 'classCode': classCode}
res = class_ctrl.removeStudent(dynamodb, jsonData, userRole=userRole)
self.assertTrue(res.hasErrors())
self.assertEqual(
res.errors[0], {
'message': 'Unable to find user',
'title': 'Failed to remove student from class'
})
#check class wasn't removed from student
jsonData = {'Key': {'email': email}}
response = db.getItem(jsonData, usersTable)
self.assertIsNotNone(response.get('Item'))
classCodes = response.get('Item').get('classCodes')
self.assertTrue(classCode in classCodes)