def setUp(self):
super(BaseApiTest, self).setUp()
self.admin = Administrator()
self.admin.from_dict({
'name': 'admin',
'username': '******',
'password': '******'
})
db.session.add(self.admin)
self.teacher = Teacher()
self.teacher.from_dict({
'name': 'teacher',
'username': '******',
'password': '******'
})
db.session.add(self.teacher)
self.student = Student()
self.student.from_dict({
'name': 'student',
'username': '******',
'password': '******'
})
db.session.add(self.student)
db.session.commit()
def test_remove_teacher(self):
# create a teacher
teacher = Teacher()
teacher.from_dict({'username': '******', 'name': 'n', 'password': '******'})
db.session.add(teacher)
db.session.commit()
number_of_teachers_before = len(Teacher.query.all())
# try to access with basic authentication
rv = self.client.delete(f'/api/v1/admin/teacher/{teacher.id}',
headers=self.basic_auth_header(
'admin', 'admin'))
self.assertEquals(rv.status_code, 401)
# get token
rv = self.client.post('/api/v1/auth/token',
headers=self.basic_auth_header('admin', 'admin'))
self.assertEquals(rv.status_code, 200)
token = json.loads(rv.data.decode())['token']
# access with token
rv = self.client.delete(f'/api/v1/admin/teacher/{teacher.id}',
headers=self.token_auth_header(token))
self.assertEquals(rv.status_code, 200)
number_of_teachers_after = len(Teacher.query.all())
self.assertEquals(number_of_teachers_before - number_of_teachers_after,
1)
# try to remove a nonexistent teacher
rv = self.client.delete(f'/api/v1/admin/teacher/{teacher.id}',
headers=self.token_auth_header(token))
self.assertEquals(rv.status_code, 410)
def create_teacher():
data = request.get_json() or {}
if not all(field in data for field in ['name', 'username', 'password']):
return '', 400
teacher = Teacher()
teacher.from_dict(data)
db.session.add(teacher)
db.session.commit()
return '', 200
def test_course(self):
# create invalid course
course = Course()
db.session.add(course)
self.assertRaises(IntegrityError, db.session.commit)
db.session.rollback()
# try to create course without a teacher
course.from_dict({'name': 'course', 'description': 'course'})
db.session.add(course)
self.assertIsNone(course.teacher_id)
# create a teacher
teacher = Teacher()
teacher.from_dict({
'name': 'teacher',
'username': '******',
'password': '******'
})
db.session.add(teacher)
db.session.commit()
# add teacher to course
course.teacher_id = teacher.id
db.session.add(course)
db.session.commit()
# check data
self.assertEquals(len(Course.query.all()), 1)
self.assertIsNotNone(course.id)
self.assertEquals(course.teacher_id, teacher.id)
d = course.to_dict()
self.assertIsNotNone(d['id'])
self.assertEquals(d['name'], 'course')
self.assertEquals(d['description'], 'course')
self.assertEquals(d['teacher'], 'teacher')
# try to create course with the same name
course2 = Course()
course2.from_dict({'name': 'course', 'description': 'course2'})
course2.teacher_id = teacher.id
db.session.add(course2)
self.assertRaises(IntegrityError, db.session.commit)
db.session.rollback()
def test_teacher(self):
# create invalid teacher
teacher = Teacher()
db.session.add(teacher)
self.assertRaises(IntegrityError, db.session.commit)
db.session.rollback()
# create valid teacher
teacher.from_dict({
'name': 'teacher',
'username': '******',
'password': '******'
})
db.session.add(teacher)
db.session.commit()
# check data
self.assertEquals(len(Teacher.query.all()), 1)
self.assertIsNotNone(teacher.id)
self.assertNotEquals(teacher.password_hash, 'teacher')
self.assertEquals(teacher.type, 'teachers')
d = teacher.to_dict()
self.assertIsNotNone(d['id'])
self.assertEquals(d['username'], 'teacher')
self.assertEquals(d['name'], 'teacher')
# try to create teacher with the same username
teacher2 = Teacher()
teacher2.from_dict({
'name': 'teacher2',
'username': '******',
'password': '******'
})
db.session.add(teacher2)
self.assertRaises(IntegrityError, db.session.commit)
db.session.rollback()
from homework_server import db
db.drop_all()
db.create_all()
from homework_server.models import Administrator
admin_user = Administrator()
admin_user.name = 'admin'
admin_user.username = '******'
admin_user.set_password('admin')
db.session.add(admin_user)
db.session.commit()
from homework_server.models import Teacher
t = Teacher()
t.name = 't'
t.username = '******'
t.set_password('t')
db.session.add(t)
db.session.commit()
from homework_server.models import Student
s = Student()
s.name = 's'
s.username = '******'
s.set_password('s')
db.session.add(s)
db.session.commit()
from homework_server.models import Course
def test_student(self):
# create invalid student
student = Student()
db.session.add(student)
self.assertRaises(IntegrityError, db.session.commit)
db.session.rollback()
# create valid student
student.from_dict({
'name': 'student',
'username': '******',
'password': '******'
})
db.session.add(student)
db.session.commit()
# check data
self.assertEquals(len(Student.query.all()), 1)
self.assertIsNotNone(student.id)
self.assertNotEquals(student.password_hash, 'student')
self.assertEquals(student.type, 'students')
d = student.to_dict()
self.assertIsNotNone(d['id'])
self.assertEquals(d['username'], 'student')
self.assertEquals(d['name'], 'student')
# try to create student with the same username
student2 = Student()
student2.from_dict({
'name': 'student2',
'username': '******',
'password': '******'
})
db.session.add(student2)
self.assertRaises(IntegrityError, db.session.commit)
db.session.rollback()
# create a teacher
teacher = Teacher()
teacher.from_dict({
'name': 'teacher',
'username': '******',
'password': '******'
})
db.session.add(teacher)
db.session.commit()
# create a course and add student to it
course = Course()
course.from_dict({'name': 'course', 'description': 'course'})
course.teacher_id = teacher.id
course.students.append(student)
db.session.add(course)
db.session.commit()
# check if student has one course
self.assertEquals(len(student.courses), 1)
# create a homework and add student to it
homework = Homework()
homework.from_dict({
'name': 'homework',
'description': 'homework',
'deadline': datetime.utcnow(),
'headcount': 2,
'self_assignable': True
})
homework.course_id = course.id
homework.students.append(student)
db.session.add(homework)
db.session.commit()
# check if student has one homework
self.assertEquals(len(student.homeworks), 1)
def test_solution(self):
# create invalid solution
solution = Solution()
db.session.add(solution)
self.assertRaises(IntegrityError, db.session.commit)
db.session.rollback()
# try to create solution without file_path
solution.from_dict({'status': 'status'})
db.session.add(solution)
self.assertRaises(IntegrityError, db.session.commit)
db.session.rollback()
# try to create solution without a homework
solution.file_path = 'file_path'
db.session.add(solution)
self.assertRaises(IntegrityError, db.session.commit)
db.session.rollback()
# create a teacher
teacher = Teacher()
teacher.from_dict({
'name': 'teacher',
'username': '******',
'password': '******'
})
db.session.add(teacher)
db.session.commit()
# create a course
course = Course()
course.from_dict({'name': 'course', 'description': 'course'})
course.teacher_id = teacher.id
db.session.add(course)
db.session.commit()
# create a homework
homework = Homework()
homework.from_dict({
'name': 'homework',
'description': 'homework',
'deadline': '2018-10-30 10:20:32',
'headcount': 2,
'self_assignable': True
})
homework.course_id = course.id
db.session.add(homework)
db.session.commit()
# add homework to solution
solution.homework_id = homework.id
db.session.add(solution)
db.session.commit()
# check data
submitted_at = datetime.utcnow()
self.assertEquals(len(Solution.query.all()), 1)
self.assertIsNotNone(solution.id)
self.assertEquals(solution.homework_id, homework.id)
d = solution.to_dict()
self.assertIsNotNone(d['id'])
self.assertEquals(sorted(d.keys()), ['id', 'status', 'submitted_at'])
self.assertEquals(d['status'], 'status')
self.assertTrue(
abs((submitted_at -
datetime.strptime(d['submitted_at'], '%Y-%m-%d %H:%M:%S')
).seconds) < 1)
def test_homework(self):
# create invalid homework
homework = Homework()
db.session.add(homework)
self.assertRaises(IntegrityError, db.session.commit)
db.session.rollback()
# try to create homework without a course
homework.from_dict({
'name': 'homework',
'description': 'homework',
'deadline': '2018-10-30 10:20:32',
'headcount': 2,
'self_assignable': True
})
db.session.add(homework)
self.assertRaises(IntegrityError, db.session.commit)
db.session.rollback()
# create a teacher
teacher = Teacher()
teacher.from_dict({
'name': 'teacher',
'username': '******',
'password': '******'
})
db.session.add(teacher)
db.session.commit()
# create a course
course = Course()
course.from_dict({'name': 'course', 'description': 'course'})
course.teacher_id = teacher.id
db.session.add(course)
db.session.commit()
# add course to homework
homework.course_id = course.id
db.session.add(homework)
db.session.commit()
# check data
self.assertEquals(len(Homework.query.all()), 1)
self.assertIsNotNone(homework.id)
self.assertEquals(homework.course_id, course.id)
d = homework.to_dict()
self.assertIsNotNone(d['id'])
self.assertEquals(d['name'], 'homework')
self.assertEquals(d['description'], 'homework')
self.assertEquals(d['deadline'], '2018-10-30 10:20:32')
self.assertEquals(d['headcount'], 2)
self.assertTrue(d['self_assignable'])
self.assertEquals(d['course'], 'course')
# try to create homework with the same name
homework2 = Homework()
homework2.from_dict({
'name': 'homework',
'description': 'homework2',
'deadline': datetime.utcnow(),
'headcount': 3,
'self_assignable': False
})
homework2.course_id = course.id
db.session.add(homework2)
self.assertRaises(IntegrityError, db.session.commit)
db.session.rollback()
class BaseApiTest(BaseTest):
def setUp(self):
super(BaseApiTest, self).setUp()
self.admin = Administrator()
self.admin.from_dict({
'name': 'admin',
'username': '******',
'password': '******'
})
db.session.add(self.admin)
self.teacher = Teacher()
self.teacher.from_dict({
'name': 'teacher',
'username': '******',
'password': '******'
})
db.session.add(self.teacher)
self.student = Student()
self.student.from_dict({
'name': 'student',
'username': '******',
'password': '******'
})
db.session.add(self.student)
db.session.commit()
def basic_auth_header(self, username, password):
headers = {
'Accept': 'application/json',
'Content-type': 'application/json'
}
credentials = base64.b64encode(f'{username}:{password}'.encode()).decode('utf-8')
headers['Authorization'] = f'Basic {credentials}'
return headers
def token_auth_header(self, token):
headers = {
'Accept': 'application/json',
'Content-type': 'application/json'
}
headers['Authorization'] = f'Bearer {token}'
return headers
def insufficient_datas(self, data):
fields = list(data.keys())
combinations = []
for i in range(1, len(fields)):
combinations.append(list(itertools.combinations(fields, i)))
request_datas = []
for l1 in combinations:
for l2 in l1:
d = {}
for f in l2:
d[f] = data[f]
request_datas.append(d)
return request_datas
def test_pagination(self):
# remove default teacher
db.session.delete(self.teacher)
# create 55 teachers
for i in range(55):
t = Teacher()
t.name = f't{i:02}'
t.username = f't{i:02}'
t.set_password(f't{i:02}')
db.session.add(t)
db.session.commit()
# get token
rv = self.client.post('/api/v1/auth/token',
headers=self.basic_auth_header('admin', 'admin'))
self.assertEquals(rv.status_code, 200)
token = json.loads(rv.data.decode())['token']
# access with token (items 0-24)
rv = self.client.get('/api/v1/admin/teachers',
headers=self.token_auth_header(token))
self.assertEquals(rv.status_code, 200)
# check returned data
data = json.loads(rv.data.decode())
self.assertEquals(len(data['teachers']), 25)
for i in range(0, 25):
self.assertEquals(data['teachers'][i]['name'], f't{i:02}')
self.assertIsNotNone(data['next'])
self.assertIsNone(data['prev'])
# get next page (items 25-49)
rv = self.client.get(data['next'],
headers=self.token_auth_header(token))
self.assertEquals(rv.status_code, 200)
# check returned data
data = json.loads(rv.data.decode())
self.assertEquals(len(data['teachers']), 25)
for i in range(25, 50):
self.assertEquals(data['teachers'][i - 25]['name'], f't{i:02}')
self.assertIsNotNone(data['next'])
self.assertIsNotNone(data['prev'])
# get next page (items 49-54)
rv = self.client.get(data['next'],
headers=self.token_auth_header(token))
self.assertEquals(rv.status_code, 200)
# check returned data
data = json.loads(rv.data.decode())
self.assertEquals(len(data['teachers']), 5)
for i in range(50, 55):
self.assertEquals(data['teachers'][i - 50]['name'], f't{i:02}')
self.assertIsNone(data['next'])
self.assertIsNotNone(data['prev'])
# get previous page (items 25-49)
rv = self.client.get(data['prev'],
headers=self.token_auth_header(token))
self.assertEquals(rv.status_code, 200)
# check returned data
data = json.loads(rv.data.decode())
self.assertEquals(len(data['teachers']), 25)
for i in range(25, 50):
self.assertEquals(data['teachers'][i - 25]['name'], f't{i:02}')
self.assertIsNotNone(data['next'])
self.assertIsNotNone(data['prev'])
# get previous page (items 0-24)
rv = self.client.get(data['prev'],
headers=self.token_auth_header(token))
self.assertEquals(rv.status_code, 200)
# check returned data
data = json.loads(rv.data.decode())
self.assertEquals(len(data['teachers']), 25)
for i in range(0, 25):
self.assertEquals(data['teachers'][i]['name'], f't{i:02}')
self.assertIsNotNone(data['next'])
self.assertIsNone(data['prev'])