def setUp(self):
super(SubjectAPITestCase, self).setUp()
self.school_factory = SchoolFactory()
self.user_factory = UserFactory()
self.school = self.school_factory.new_into_db()
self.user = self.user_factory.new_into_db(
school_id=self.school.id,
permissions=['Administrator']
)
self.subject_factory = SubjectFactory(self.school)
def setUp(self):
super(WeekAPITestCase, self).setUp()
self.school_factory = SchoolFactory()
self.school = self.school_factory.new_into_db()
self.user_factory = UserFactory(school=self.school)
self.user = self.user_factory.new_into_db(
school_id=self.school.id,
permissions=['Administrator', 'Teacher', 'Student'])
self.week_factory = WeekFactory(school=self.school)
self.period_factory = PeriodFactory(school=self.school)
def setUp(self):
super(EssayAPITestCase, self).setUp()
self.school_factory = SchoolFactory()
self.school = self.school_factory.new_into_db()
self.user_factory = UserFactory(school=self.school)
self.user = self.user_factory.new_into_db(
school_id=self.school.id,
permissions=['Administrator', 'Teacher', 'Student'])
self.comment_factory = CommentFactory(self.school)
self.essay_factory = EssayFactory(self.school)
self.lesson_factory = LessonFactory(self.school)
self.essay_submission_factory = EssaySubmissionFactory(self.school)
def setUp(self):
super(QuizAPITestCase, self).setUp()
self.school_factory = SchoolFactory()
self.school = self.school_factory.new_into_db()
self.user_factory = UserFactory(school=self.school)
self.user = self.user_factory.new_into_db(
school_id=self.school.id,
permissions=['Administrator', 'Teacher', 'Student'])
self.subject_factory = SubjectFactory(self.school)
self.lesson_factory = LessonFactory(self.school)
self.quiz_factory = QuizFactory(self.school)
self.quiz_submission_factory = QuizSubmissionFactory(self.school)
def test_post_request_creates_user(self, client):
user = UserFactory.build()
sent = user_schema.dump(user)
sent["password"] = "******"
del sent["id"]
response = client.post(
"/users", data=json.dumps(sent), content_type="application/json"
)
assert response.status == "201 CREATED"
recv = response.get_json()
assert recv is not None
assert "id" in recv
user = User.query.get(recv["id"])
assert user is not None
assert user.id == recv["id"]
for key in ["username", "email"]:
assert sent[key] == recv[key]
assert sent[key] == getattr(user, key)
assert "password" not in recv
assert user.check_password(sent["password"])
class WeekAPITestCase(APITestCase):
def setUp(self):
super(WeekAPITestCase, self).setUp()
self.school_factory = SchoolFactory()
self.school = self.school_factory.new_into_db()
self.user_factory = UserFactory(school=self.school)
self.user = self.user_factory.new_into_db(
school_id=self.school.id,
permissions=['Administrator', 'Teacher', 'Student'])
self.week_factory = WeekFactory(school=self.school)
self.period_factory = PeriodFactory(school=self.school)
def tearDown(self):
super(WeekAPITestCase, self).tearDown()
def test_week_create(self):
token = self.get_auth_token(username=self.user.username,
password=self.user.raw_password)
week = self.week_factory.new()
response = self.client.post('/timetable/week',
data=json.dumps({'name': week.name}),
headers={
'Content-Type': 'application/json',
'Authorization': 'JWT ' + token
})
self.assertEqual(response.status_code, 201)
json_response = json.loads(response.data.decode('utf-8'))
self.assertEqual(json_response['name'], week.name)
self.assertEqual(json_response['school_id'], week.school_id)
def test_post_request_fails_if_attribute_is_invalid(self, client, attribute, value):
user = UserFactory.build()
data = user_schema.dump(user)
data[attribute] = value
data["password"] = "******"
response = client.post(
"/users", data=json.dumps(data), content_type="application/json"
)
assert response.status == "422 UNPROCESSABLE ENTITY"
assert attribute in response.get_json()["details"]
def test_post_request_fails_if_attribute_exists(self, attribute, user, client):
user, existing_user = UserFactory.build(), user
data = user_schema.dump(user)
data[attribute] = getattr(existing_user, attribute)
data["password"] = "******"
del data["id"]
response = client.post(
"/users", data=json.dumps(data), content_type="application/json"
)
assert response.status == "400 BAD REQUEST"
assert attribute in response.get_json()["details"]
class EssayAPITestCase(APITestCase):
def setUp(self):
super(EssayAPITestCase, self).setUp()
self.school_factory = SchoolFactory()
self.school = self.school_factory.new_into_db()
self.user_factory = UserFactory(school=self.school)
self.user = self.user_factory.new_into_db(
school_id=self.school.id,
permissions=['Administrator', 'Teacher', 'Student'])
self.comment_factory = CommentFactory(self.school)
self.essay_factory = EssayFactory(self.school)
self.lesson_factory = LessonFactory(self.school)
self.essay_submission_factory = EssaySubmissionFactory(self.school)
def tearDown(self):
super(EssayAPITestCase, self).tearDown()
def test_comment_create(self):
token = self.get_auth_token(username=self.user.username,
password=self.user.raw_password)
lesson = self.lesson_factory.new_into_db(teachers=[self.user])
essay = self.essay_factory.new_into_db(lesson_id=lesson.id)
submission = self.essay_submission_factory.new_into_db(essay=essay)
comment = self.comment_factory.new(submission_id=submission.id,
user_id=self.user.id)
comment_json = comment.to_dict()
response = self.client.post('/homework/comment',
data=json.dumps(comment_json),
headers={
'Content-Type': 'application/json',
'Authorization': 'JWT ' + token
})
self.assertEqual(response.status_code, 201)
def test_comment_delete(self):
token = self.get_auth_token(username=self.user.username,
password=self.user.raw_password)
comment = self.comment_factory.new_into_db()
response = self.client.delete('/homework/comment/{}'.format(
comment.id),
headers={
'Content-Type': 'application/json',
'Authorization': 'JWT ' + token
})
self.assertEqual(response.status_code, 200)
def test_user_is_created():
user = UserFactory.build(username="******", email="*****@*****.**")
assert user.id is None
assert user.username == "john"
assert user.email == "*****@*****.**"
assert user.check_password("example")
assert user.token is None
assert user.token_expiration is None
assert user.is_admin is None
assert str(user) == "<User john>"
def new(self, submission_id=None, user_id=None):
if submission_id is None:
submission = EssaySubmissionFactory(
school=self.school).new_into_db()
submission_id = submission.id
if user_id is None:
user = UserFactory(school=self.school).new_into_db(
permissions=['Teacher'])
user_id = user.id
comment = Comment(text=fake.first_name(),
user_id=user_id,
submission_id=submission_id)
comment.id = fake.random_int()
return comment
def new(self, essay=None, user_id=None):
if essay is None:
essay = EssayFactory(school=self.school).new_into_db()
if user_id is None:
user = UserFactory(school=self.school).new_into_db(
permissions=['Student'])
user_id = user.id
submission = EssaySubmission(
homework_id=essay.id,
user_id=user_id,
datetime_submitted=datetime.datetime.now(),
text=fake.first_name())
submission.id = fake.random_int()
return submission
def new(self, quiz=None, user_id=None):
if user_id is None:
user = UserFactory(school=self.school).new_into_db(
permissions=['Student'])
user_id = user.id
if quiz is None:
quiz = QuizFactory(school=self.school).new_into_db()
submission = QuizSubmission(homework_id=quiz.id,
user_id=user_id,
datetime_submitted=datetime.datetime.now())
submission.id = fake.random_int()
for question in quiz.questions:
answer = QuizAnswer(fake.first_name(), submission.id, question.id)
submission.answers.append(answer)
return submission
class QuizAPITestCase(APITestCase):
def setUp(self):
super(QuizAPITestCase, self).setUp()
self.school_factory = SchoolFactory()
self.school = self.school_factory.new_into_db()
self.user_factory = UserFactory(school=self.school)
self.user = self.user_factory.new_into_db(
school_id=self.school.id,
permissions=['Administrator', 'Teacher', 'Student'])
self.subject_factory = SubjectFactory(self.school)
self.lesson_factory = LessonFactory(self.school)
self.quiz_factory = QuizFactory(self.school)
self.quiz_submission_factory = QuizSubmissionFactory(self.school)
def tearDown(self):
super(QuizAPITestCase, self).tearDown()
def test_quiz_create(self):
token = self.get_auth_token(username=self.user.username,
password=self.user.raw_password)
lesson = self.lesson_factory.new_into_db(teachers=[self.user])
quiz = self.quiz_factory.new(lesson.id)
quiz_json = quiz.to_dict(date_as_string=True)
response = self.client.post('/homework/quiz',
data=json.dumps(quiz_json),
headers={
'Content-Type': 'application/json',
'Authorization': 'JWT ' + token
})
self.assertEqual(response.status_code, 201)
def test_quiz_submit(self):
token = self.get_auth_token(username=self.user.username,
password=self.user.raw_password)
lesson = self.lesson_factory.new_into_db(students=[self.user])
quiz = self.quiz_factory.new_into_db(lesson_id=lesson.id)
predicted_score = 0
answer_json = {'answers': []}
for question in quiz.questions:
answer_json['answers'].append({
'question_id': question.id,
'answer': question.question_answer
})
predicted_score += 1
response = self.client.post('/homework/quiz/{}'.format(quiz.id),
data=json.dumps(answer_json),
headers={
'Content-Type': 'application/json',
'Authorization': 'JWT ' + token
})
self.assertEqual(response.status_code, 200)
json_response = json.loads(response.data.decode('utf-8'))
self.assertIn('score', json_response.keys())
self.assertEqual(json_response['score'], predicted_score)
def test_quiz_detail(self):
token = self.get_auth_token(self.user.username, self.user.raw_password)
lesson = self.lesson_factory.new_into_db(students=[self.user])
quiz = self.quiz_factory.new_into_db(lesson_id=lesson.id)
response = self.client.get('/homework/quiz/{}'.format(quiz.id),
headers={
'Content-Type': 'application/json',
'Authorization': 'JWT ' + token
})
self.assertEqual(response.status_code, 200)
json_response = json.loads(response.data.decode('utf-8'))
self.assertIn('quiz', json_response.keys())
self.assertEqual(quiz.id, json_response['quiz']['id'])
def test_view_quiz_submission(self):
token = self.get_auth_token(self.user.username, self.user.raw_password)
quiz = self.quiz_factory.new_into_db()
submission = self.quiz_submission_factory.new_into_db()
response = self.client.get('/homework/quiz/submission/{}'.format(
submission.id),
headers={
'Content-Type': 'application/json',
'Authorization': 'JWT ' + token
})
self.assertEqual(response.status_code, 200)
json_response = json.loads(response.data.decode('utf-8'))
self.assertIn('submission', json_response.keys())
self.assertEqual(submission.id, json_response['submission']['id'])
def user(database):
user = UserFactory.create()
database.session.commit()
return user
def users(database):
users = UserFactory.create_batch(25) # fill more than 2 pages
database.session.commit()
return users
def admin(database):
user = UserFactory.create(username="******")
user.is_admin = True
database.session.commit()
return user
class LessonAPITestCase(APITestCase):
def setUp(self):
super(LessonAPITestCase, self).setUp()
self.school_factory = SchoolFactory()
self.school = self.school_factory.new_into_db()
self.user_factory = UserFactory(school=self.school)
self.user = self.user_factory.new_into_db(
school_id=self.school.id, permissions=['Administrator'])
self.subject_factory = SubjectFactory(self.school)
self.lesson_factory = LessonFactory(self.school)
def tearDown(self):
super(LessonAPITestCase, self).tearDown()
def test_lesson_create(self):
lesson = self.lesson_factory.new()
self.user_factory.new_into_db()
for i in range(0, 3):
# lesson.teachers.append(self.user_factory.new_into_db())
# lesson.students.append(self.user_factory.new_into_db())
pass
lesson_as_json = lesson.to_dict()
lesson_as_json['teacher_ids'] = [
self.user_factory.new_into_db().id for i in range(0, 3)
]
lesson_as_json['student_ids'] = [
self.user_factory.new_into_db().id for i in range(0, 3)
]
token = self.get_auth_token(username=self.user.username,
password=self.user.raw_password)
response = self.client.post('/lessons/lesson',
data=json.dumps(lesson_as_json),
headers={
'Content-Type': 'application/json',
'Authorization': 'JWT ' + token
})
self.assertEqual(response.status_code, 201)
lesson_from_db = Lesson.query.filter_by(
name=lesson.name, school_id=lesson.school_id).first()
self.assertIsNotNone(lesson_from_db)
json_response = json.loads(response.data.decode('utf-8'))
self.assertIn('lesson', json_response.keys())
self.assertIn('teachers', json_response['lesson'].keys())
for teacher_id in lesson_as_json['teacher_ids']:
teacher = User.query.get(teacher_id)
self.assertIn(teacher.to_dict(),
json_response['lesson']['teachers'])
self.assertIn('students', json_response['lesson'].keys())
for student_id in lesson_as_json['student_ids']:
student = User.query.get(student_id)
self.assertIn(student.to_dict(),
json_response['lesson']['students'])
def test_lesson_listing(self):
lessons = [self.lesson_factory.new_into_db()]
token = self.get_auth_token(username=self.user.username,
password=self.user.raw_password)
response = self.client.get('/lessons/lesson',
headers={
'Content-Type': 'application/json',
'Authorization': 'JWT ' + token
})
self.assertEqual(response.status_code, 200)
json_response = json.loads(response.data.decode('utf-8'))
self.assertIn('lessons', json_response.keys())
for lesson in lessons:
self.assertIn(lesson.to_dict(), json_response['lessons'])
def test_lesson_listing_with_subject(self):
subject1 = self.subject_factory.new_into_db()
subject2 = self.subject_factory.new_into_db()
lesson1 = self.lesson_factory.new_into_db(subject=subject1)
lesson2 = self.lesson_factory.new_into_db(subject=subject2)
token = self.get_auth_token(username=self.user.username,
password=self.user.raw_password)
response = self.client.get('/lessons/lesson?subject={}'.format(
subject1.id),
headers={
'Content-Type': 'application/json',
'Authorization': 'JWT ' + token
})
self.assertEqual(response.status_code, 200)
json_response = json.loads(response.data.decode('utf-8'))
self.assertIn('lessons', json_response.keys())
self.assertIn(lesson1.to_dict(), json_response['lessons'])
self.assertNotIn(lesson2.to_dict(), json_response['lessons'])
def test_lesson_detail(self):
lesson = self.lesson_factory.new_into_db()
token = self.get_auth_token(username=self.user.username,
password=self.user.raw_password)
response = self.client.get('/lessons/lesson/{}'.format(lesson.id),
headers={
'Content-Type': 'application/json',
'Authorization': 'JWT ' + token
})
self.assertEqual(response.status_code, 200)
json_response = json.loads(response.data.decode('utf-8'))
self.assertIn('lesson', json_response.keys())
# Make sure our lesson is in data returned
self.assertEqual(lesson.to_dict(), json_response['lesson'])
def test_lesson_delete(self):
lesson = self.lesson_factory.new_into_db()
token = self.get_auth_token(username=self.user.username,
password=self.user.raw_password)
response = self.client.delete(
'/lessons/lesson/{}'.format(lesson.id),
headers={'Authorization': 'JWT ' + token})
self.assertEqual(response.status_code, 200)
lesson_from_db = Lesson.query.get(lesson.id)
self.assertIsNone(lesson_from_db)
def test_lesson_update(self):
lesson = self.lesson_factory.new_into_db()
token = self.get_auth_token(username=self.user.username,
password=self.user.raw_password)
json_update = {}
json_update[
'name'] = "new_name" if lesson.name != "new_name" else "another_name"
json_update['teacher_ids'] = [
self.user_factory.new_into_db().id for i in range(0, 3)
]
json_update['student_ids'] = [
self.user_factory.new_into_db().id for i in range(0, 3)
]
json_update['subject_id'] = self.subject_factory.new_into_db().id
response = self.client.put('/lessons/lesson/{}'.format(lesson.id),
data=json.dumps(json_update),
headers={
'Authorization': 'JWT ' + token,
'Content-Type': 'application/json'
})
self.assertEqual(response.status_code, 200)
lesson_from_db = Lesson.query.get(lesson.id)
self.assertIsNotNone(lesson_from_db)
self.assertEqual(lesson_from_db.name, json_update['name'])
self.assertEqual(lesson_from_db.subject_id, json_update['subject_id'])
self.assertEqual(sorted([t.id for t in lesson_from_db.teachers]),
sorted(json_update['teacher_ids']))
self.assertEqual(sorted([s.id for s in lesson_from_db.students]),
sorted(json_update['student_ids']))
def test_update_lesson_failed_bad_id(self):
# Create lesson
lesson = self.lesson_factory.new_into_db()
# Send request
token = self.get_auth_token(self.user.username, self.user.raw_password)
response = self.client.put('/lessons/lesson/{}'.format(-1),
data=json.dumps({}),
headers={
'Content-Type': 'application/json',
'Authorization': 'JWT ' + token
})
# Check status code
self.assertEqual(response.status_code, 404)
def test_read_lesson_failed_bad_id(self):
# Create lesson
lesson = self.lesson_factory.new_into_db()
# Send request
token = self.get_auth_token(self.user.username, self.user.raw_password)
response = self.client.get('/lessons/lesson/{}'.format(-1),
data=json.dumps({}),
headers={
'Content-Type': 'application/json',
'Authorization': 'JWT ' + token
})
# Check status code
self.assertEqual(response.status_code, 404)
def test_delete_lesson_failed_bad_id(self):
# Create lesson
lesson = self.lesson_factory.new_into_db()
# Send request
token = self.get_auth_token(self.user.username, self.user.raw_password)
response = self.client.delete('/lessons/lesson/{}'.format(-1),
data=json.dumps({}),
headers={
'Content-Type': 'application/json',
'Authorization': 'JWT ' + token
})
# Check status code
self.assertEqual(response.status_code, 404)
class SubjectAPITestCase(APITestCase):
def setUp(self):
super(SubjectAPITestCase, self).setUp()
self.school_factory = SchoolFactory()
self.user_factory = UserFactory()
self.school = self.school_factory.new_into_db()
self.user = self.user_factory.new_into_db(
school_id=self.school.id,
permissions=['Administrator']
)
self.subject_factory = SubjectFactory(self.school)
def tearDown(self):
super(SubjectAPITestCase, self).tearDown()
def test_create_subject(self):
subject = self.subject_factory.new()
token = self.get_auth_token(self.user.username, self.user.raw_password)
response = self.client.post(
'/lessons/subject',
data=json.dumps(subject.to_dict()),
headers={
'Content-Type': 'application/json',
'Authorization': 'JWT ' + token
}
)
self.assertEqual(response.status_code, 201)
subject_from_db = Subject.query.filter_by(
name=subject.name, school_id=self.school.id).first()
self.assertIsNotNone(subject_from_db)
def test_list_subjects(self):
# Create subject
subject = self.subject_factory.new_into_db()
# Get JWT token needed
token = self.get_auth_token(self.user.username, self.user.raw_password)
# Send request and get response
response = self.client.get(
'/lessons/subject',
headers={'Authorization': 'JWT ' + token}
)
# Check response status code is 200
self.assertEqual(response.status_code, 200)
# Parse json returned
# response.data is a bytes not a string so needs to be converted
json_data = json.loads(response.data.decode('utf-8'))
# Make sure JSON returned has the key subjects
self.assertIn('subjects', json_data.keys())
# Make sure our subject is in data returned
self.assertIn(subject.to_dict(), json_data['subjects'])
def test_subject_detail(self):
# Create subject
subject = self.subject_factory.new_into_db()
# Get JWT token needed
token = self.get_auth_token(self.user.username, self.user.raw_password)
# Send request and get response
response = self.client.get(
'/lessons/subject/{}'.format(subject.id),
headers={'Authorization': 'JWT ' + token}
)
# Check response status code is 200
self.assertEqual(response.status_code, 200)
# Parse json returned
# response.data is a bytes not a string so needs to be converted
json_data = json.loads(response.data.decode('utf-8'))
# Make sure JSON returned has the key subject
self.assertIn('subject', json_data.keys())
# Make sure our subject is in data returned
self.assertEqual(subject.to_dict(), json_data['subject'])
def test_update_subject(self):
# Create subject
subject = self.subject_factory.new_into_db()
# Generate new name
new_name = 'New Name'
# Assert names are different
self.assertNotEqual(subject.name, new_name)
# Send request
token = self.get_auth_token(self.user.username, self.user.raw_password)
response = self.client.put(
'/lessons/subject/{}'.format(subject.id),
data=json.dumps({'name': new_name}),
headers={'Content-Type': 'application/json', 'Authorization': 'JWT ' + token}
)
# Check status code
self.assertEqual(response.status_code, 200)
# Check subject updated
subject = Subject.query.get(subject.id)
self.assertEqual(subject.name, new_name)
def test_update_subject_failed_bad_id(self):
# Create subject
subject = self.subject_factory.new_into_db()
# Send request
token = self.get_auth_token(self.user.username, self.user.raw_password)
response = self.client.put(
'/lessons/subject/{}'.format(-1),
data=json.dumps({}),
headers={'Content-Type': 'application/json', 'Authorization': 'JWT ' + token}
)
# Check status code
self.assertEqual(response.status_code, 404)
def test_delete_subject(self):
# Create subject
subject = self.subject_factory.new_into_db()
# Assert that subject is in the database
subject_from_db = Subject.query.get(subject.id)
self.assertIsNotNone(subject_from_db)
# Get JWT token needed
token = self.get_auth_token(self.user.username, self.user.raw_password)
# Send request and get response
response = self.client.delete(
'/lessons/subject/{}'.format(subject.id),
headers={'Authorization': 'JWT ' + token}
)
# Check response status code is 200
self.assertEqual(response.status_code, 200)
# Check subject is no longer in database
subject_from_db = Subject.query.get(subject.id)
self.assertIsNone(subject_from_db)
def test_read_subject_failed_bad_id(self):
# Create subject
subject = self.subject_factory.new_into_db()
# Send request
token = self.get_auth_token(self.user.username, self.user.raw_password)
response = self.client.get(
'/subjects/subject/{}'.format(-1),
data=json.dumps({}),
headers={'Content-Type': 'application/json', 'Authorization': 'JWT ' + token}
)
# Check status code
self.assertEqual(response.status_code, 404)
def test_delete_subject_failed_bad_id(self):
# Create subject
subject = self.subject_factory.new_into_db()
# Send request
token = self.get_auth_token(self.user.username, self.user.raw_password)
response = self.client.delete(
'/subjects/subject/{}'.format(-1),
data=json.dumps({}),
headers={'Content-Type': 'application/json', 'Authorization': 'JWT ' + token}
)
# Check status code
self.assertEqual(response.status_code, 404)
class HomeworkAPITestCase(APITestCase):
def setUp(self):
super(HomeworkAPITestCase, self).setUp()
self.school_factory = SchoolFactory()
self.school = self.school_factory.new_into_db()
self.user_factory = UserFactory(school=self.school)
self.user = self.user_factory.new_into_db(
school_id=self.school.id,
permissions=['Administrator', 'Teacher', 'Student'])
self.subject_factory = SubjectFactory(self.school)
self.lesson_factory = LessonFactory(self.school)
self.quiz_factory = QuizFactory(self.school)
self.essay_submission_factory = EssaySubmissionFactory(self.school)
self.quiz_submission_factory = QuizSubmissionFactory(self.school)
def tearDown(self):
super(HomeworkAPITestCase, self).tearDown()
def test_submission_listing_for_students(self):
token = self.get_auth_token(username=self.user.username,
password=self.user.raw_password)
submission = self.essay_submission_factory.new_into_db(
user_id=self.user.id)
response = self.client.get('/homework/submissions',
headers={
'Content-Type': 'application/json',
'Authorization': 'JWT ' + token
})
self.assertEqual(response.status_code, 200)
json_response = json.loads(response.data.decode('utf-8'))
self.assertIn('submissions', json_response.keys())
self.assertIn(submission.id,
[s['id'] for s in json_response['submissions']])
def test_submission_listing_for_homework(self):
token = self.get_auth_token(username=self.user.username,
password=self.user.raw_password)
quiz = self.quiz_factory.new_into_db()
submission = self.quiz_submission_factory.new_into_db(quiz=quiz)
response = self.client.get('/homework/homework/{}/submissions'.format(
quiz.id),
headers={
'Content-Type': 'application/json',
'Authorization': 'JWT ' + token
})
self.assertEqual(response.status_code, 200)
json_response = json.loads(response.data.decode('utf-8'))
self.assertIn('submissions', json_response.keys())
self.assertIn(submission.id,
[s['id'] for s in json_response['submissions']])
def test_submission_listing_for_homework_failed_bad_id(self):
token = self.get_auth_token(username=self.user.username,
password=self.user.raw_password)
response = self.client.get(
'/homework/homework/{}/submissions'.format(-1),
headers={
'Content-Type': 'application/json',
'Authorization': 'JWT ' + token
})
self.assertEqual(response.status_code, 404)
def test_list_homework_for_lesson(self):
token = self.get_auth_token(username=self.user.username,
password=self.user.raw_password)
quiz = self.quiz_factory.new_into_db()
response = self.client.get('/homework/due/{}'.format(quiz.lesson.id),
headers={
'Content-Type': 'application/json',
'Authorization': 'JWT ' + token
})
self.assertEqual(response.status_code, 200)
json_response = json.loads(response.data.decode('utf-8'))
self.assertIn('homework', json_response.keys())
self.assertIn(quiz.id, [h['id'] for h in json_response['homework']])
def test_list_homework_for_lesson_failed_bad_id(self):
token = self.get_auth_token(username=self.user.username,
password=self.user.raw_password)
response = self.client.get('/homework/due/{}'.format(-1),
headers={
'Content-Type': 'application/json',
'Authorization': 'JWT ' + token
})
self.assertEqual(response.status_code, 404)
def test_homework_summary(self):
token = self.get_auth_token(username=self.user.username,
password=self.user.raw_password)
lesson = self.lesson_factory.new_into_db(students=[self.user])
quiz = self.quiz_factory.new_into_db(lesson_id=lesson.id)
response = self.client.get('/homework/summary',
headers={
'Content-Type': 'application/json',
'Authorization': 'JWT ' + token
})
self.assertEqual(response.status_code, 200)
json_response = json.loads(response.data.decode('utf-8'))
self.assertIn('homework', json_response.keys())
self.assertIn(quiz.id, [h['id'] for h in json_response['homework']])
import unittest
import json
from app import db, create_app
from tests import APITestCase
from tests.school.factories import SchoolFactory
from app.user.models import User
from tests.user.factories import UserFactory, FormFactory
from app.user.user_functions import user_listing
from internal.test_helper import AuthUser
user_factory = UserFactory()
school_factory = SchoolFactory()
form_factory = FormFactory()
class UserAPITestCase(APITestCase):
def setUp(self):
super(UserAPITestCase, self).setUp()
self.school = school_factory.new_into_db()
self.user = user_factory.new_into_db(school_id=self.school.id,
permissions=['Administrator'])
self.form = form_factory.new_into_db(school_id=self.school.id)
self.admin = AuthUser(permissions=["Administrator"],
school_id=self.school.id,
user_id=self.user.id)
def tearDown(self):
class EssayAPITestCase(APITestCase):
def setUp(self):
super(EssayAPITestCase, self).setUp()
self.school_factory = SchoolFactory()
self.school = self.school_factory.new_into_db()
self.user_factory = UserFactory(school=self.school)
self.user = self.user_factory.new_into_db(
school_id=self.school.id,
permissions=['Administrator', 'Teacher', 'Student']
)
self.subject_factory = SubjectFactory(self.school)
self.lesson_factory = LessonFactory(self.school)
self.essay_factory = EssayFactory(self.school)
self.essay_submission_factory = EssaySubmissionFactory(self.school)
def tearDown(self):
super(EssayAPITestCase, self).tearDown()
def test_essay_create(self):
token = self.get_auth_token(username=self.user.username, password=self.user.raw_password)
lesson = self.lesson_factory.new_into_db(teachers=[self.user])
essay = self.essay_factory.new(lesson.id)
essay_json = essay.to_dict(date_as_string=True)
response = self.client.post(
'/homework/essay',
data=json.dumps(essay_json),
headers={'Content-Type': 'application/json', 'Authorization': 'JWT ' + token}
)
self.assertEqual(response.status_code, 201)
def test_essay_submit(self):
token = self.get_auth_token(self.user.username, self.user.raw_password)
lesson = self.lesson_factory.new_into_db(students=[self.user])
essay = self.essay_factory.new_into_db(lesson_id=lesson.id)
essay_content = "Hello World This is my essay."
response = self.client.post(
'/homework/essay/{}'.format(essay.id),
data=json.dumps({'content': essay_content}),
headers={'Content-Type': 'application/json', 'Authorization': 'JWT ' + token}
)
self.assertEqual(response.status_code, 201)
def test_essay_detail(self):
token = self.get_auth_token(self.user.username, self.user.raw_password)
lesson = self.lesson_factory.new_into_db(students=[self.user])
essay = self.essay_factory.new_into_db(lesson_id=lesson.id)
response = self.client.get(
'/homework/essay/{}'.format(essay.id),
headers={'Content-Type': 'application/json', 'Authorization': 'JWT ' + token}
)
self.assertEqual(response.status_code, 200)
json_response = json.loads(response.data.decode('utf-8'))
self.assertIn('essay', json_response.keys())
self.assertEqual(essay.id, json_response['essay']['id'])
def test_view_essay_submission(self):
token = self.get_auth_token(self.user.username, self.user.raw_password)
essay = self.essay_factory.new_into_db()
submission = self.essay_submission_factory.new_into_db()
response = self.client.get(
'/homework/essay/submission/{}'.format(submission.id),
headers={'Content-Type': 'application/json', 'Authorization': 'JWT ' + token}
)
self.assertEqual(response.status_code, 200)
json_response = json.loads(response.data.decode('utf-8'))
self.assertIn('submission', json_response.keys())
self.assertEqual(submission.id, json_response['submission']['id'])
