def test_add_students_to_division(db: Session) -> None:
division = create_random_division(db)
assert division
students = [
create_random_student(db, term_id=division.course.term_id),
create_random_student(db, term_id=division.course.term_id),
]
random_batch = randint(1, 5)
for student in students:
division.students.append({
"student": student,
"batch_number": random_batch
})
try:
db.commit()
except exc.IntegrityError as e:
logging.error(e.__str__())
db.rollback()
except Exception as e:
logging.error(e.__str__())
db.rollback()
for student in students:
db.refresh(student)
assert student.divisions
assert student.divisions[0] == division
def test_remove_division_student(client: TestClient,
superuser_token_headers: dict[str, str],
db: Session) -> None:
course = create_random_course(db)
division = create_random_division(db, course_id=course.id)
students = [
create_random_student(db,
school_id=course.term.year.school_id,
term_id=course.term_id),
create_random_student(db,
school_id=course.term.year.school_id,
term_id=course.term_id),
]
batch_number = randint(1, 5)
for student in students:
division.students.append({
"student": student,
"batch_number": batch_number
})
try:
db.commit()
except Exception as e:
logging.error(e)
db.rollback()
r = client.delete(
f"{settings.API_V1_STR}/divisions/{division.id}/students/{students[0].user_id}",
headers=superuser_token_headers)
assert r.status_code == 200
updated_student = r.json()
assert updated_student["user_id"] == students[0].user_id
db.refresh(division)
assert students[0] not in division.students
def test_add_division_students_no_student_object(client: TestClient,
superuser_token_headers: dict[
str, str],
db: Session) -> None:
course = create_random_course(db)
division = create_random_division(db, course_id=course.id)
students = [
create_random_student(db,
school_id=course.term.year.school_id,
term_id=course.term_id),
create_random_student(db,
school_id=course.term.year.school_id,
term_id=course.term_id),
]
data = [student.user_id for student in students]
student_no_object = create_random_student(
db, school_id=course.term.year.school_id, term_id=course.term_id)
crud.student.remove(db, id=student_no_object.user_id)
data.append(student_no_object.user_id)
r = client.post(f"{settings.API_V1_STR}/divisions/{division.id}/students",
headers=superuser_token_headers,
json=data)
assert r.status_code == 207
response = r.json()
assert response.get("errors").get(
"no student object")[0] == student_no_object.user_id
for student in students:
assert student.user_id in response.get("success")
def test_get_division_batch_students(client: TestClient,
superuser_token_headers: dict[str, str],
db: Session) -> None:
course = create_random_course(db)
division = create_random_division(db, course_id=course.id)
students = [
create_random_student(db,
school_id=course.term.year.school_id,
term_id=course.term_id),
create_random_student(db,
school_id=course.term.year.school_id,
term_id=course.term_id),
]
batch_number = randint(1, 5)
for student in students:
division.students.append({
"student": student,
"batch_number": batch_number
})
try:
db.commit()
except exc.IntegrityError as e:
logging.error(e.__str__())
db.rollback()
except Exception as e:
logging.error(e.__str__())
db.rollback()
r = client.get(
f"{settings.API_V1_STR}/divisions/{division.id}/students/{batch_number}",
headers=superuser_token_headers)
assert r.status_code == 200
student_ids = [student.get("user_id") for student in r.json()]
for student in students:
assert student.user_id in student_ids
def test_get_students_normal_user(client: TestClient, normal_user_token_headers: dict[str, str], db: Session) -> None:
create_random_student(db)
create_random_student(db)
r = client.get(
f"{settings.API_V1_STR}/students/",
headers=normal_user_token_headers,
)
assert r.status_code == 403
def test_get_students(db: Session) -> None:
term = create_random_term(db)
created_students = [
create_random_student(db, term.id),
create_random_student(db, term.id)
]
db.refresh(term)
students = term.students
assert len(students) >= 2
for student in students:
assert student in created_students
def test_get_students_superuser(client: TestClient, superuser_token_headers: dict[str, str], db: Session) -> None:
create_random_student(db)
create_random_student(db)
r = client.get(
f"{settings.API_V1_STR}/students/",
headers=superuser_token_headers,
)
assert r.status_code == 200
all_students = r.json()
assert len(all_students) >= 2
for student in all_students:
assert "user_id" in student
assert "term_id" in student
def test_remove_students_from_division(db: Session) -> None:
division = create_random_division(db)
assert division
student = create_random_student(db, term_id=division.course.term_id)
division.students.append({
"student": student,
"batch_number": randint(1, 5)
})
try:
db.commit()
except exc.IntegrityError as e:
logging.error(e.__str__())
db.rollback()
except Exception as e:
logging.error(e.__str__())
db.rollback()
db.refresh(student)
assert division in student.divisions
division.students.remove(student)
try:
db.commit()
except exc.IntegrityError as e:
logging.error(e.__str__())
db.rollback()
except Exception as e:
logging.error(e.__str__())
db.rollback()
db.refresh(student)
assert division not in student.divisions
def test_get_student_divisions_id_admin_without_perms(client: TestClient, db: Session) -> None:
student = create_random_student(db)
admin = create_random_user(db, type="admin")
r = client.get(
f"{settings.API_V1_STR}/students/{student.user_id}/divisions",
headers=authentication_token_from_email(client=client, email=admin.email, db=db),
)
assert r.status_code == 403
def test_update_user_student(db: Session) -> None:
student = create_random_student(db)
assert student
term = create_random_term(db)
student_update = StudentUpdate(user_id=student.user_id, term_id=term.id)
crud.student.update(db, db_obj=student, obj_in=student_update)
user_2 = crud.student.get(db, id=student.user_id)
assert user_2
assert user_2.term_id == term.id
def test_update_students_non_admin(client: TestClient, db: Session) -> None:
student = create_random_student(db)
term_id = create_random_term(db).id
data = {"term_id": term_id}
r = client.put(
f"{settings.API_V1_STR}/students/{student.user_id}",
headers=authentication_token_from_email(client=client, email=student.user.email, db=db),
json=data,
)
assert r.status_code == 403
def test_update_user_student_with_dict(db: Session) -> None:
student = create_random_student(db)
assert student
term = create_random_term(db)
student_update = {"user_id": student.user_id, "term_id": term.id}
crud.student.update(db, db_obj=student, obj_in=student_update)
student_2 = crud.student.get(db, id=student.user_id)
assert student_2
assert student_2.user_id == student.user_id
assert student_2.term_id == term.id
def test_read_student_by_id_superuser(client: TestClient, superuser_token_headers: dict[str, str], db: Session) -> None:
student = create_random_student(db)
r = client.get(
f"{settings.API_V1_STR}/students/{student.user_id}",
headers=superuser_token_headers,
)
assert r.status_code == 200
fetched_student = r.json()
assert fetched_student
compare_api_and_db_query_results(api_result=fetched_student, db_dict=to_json(student))
def test_remove_division_student_not_in_division(client: TestClient,
superuser_token_headers: dict[
str, str],
db: Session) -> None:
division = create_random_division(db)
student = create_random_student(db)
r = client.delete(
f"{settings.API_V1_STR}/divisions/{division.id}/students/{student.user_id}",
headers=superuser_token_headers)
assert r.status_code == 404
def test_get_student_me_normal_student(client: TestClient, db: Session) -> None:
student = create_random_student(db)
r = client.get(
f"{settings.API_V1_STR}/students/me",
headers=authentication_token_from_email(client=client, email=student.user.email, db=db),
)
assert r.status_code == 200
fetched_student = r.json()
assert fetched_student
compare_api_and_db_query_results(api_result=fetched_student, db_dict=to_json(student))
def test_get_division_students_professor(client: TestClient,
db: Session) -> None:
course = create_random_course(db)
professor = create_random_user(db,
type="professor",
school_id=course.term.year.school_id)
division = create_random_division(db,
course_id=course.id,
professor_id=professor.id)
students = [
create_random_student(db,
school_id=course.term.year.school_id,
term_id=course.term_id),
create_random_student(db,
school_id=course.term.year.school_id,
term_id=course.term_id),
]
batch_number = randint(1, 5)
for student in students:
division.students.append({
"student": student,
"batch_number": batch_number
})
try:
db.commit()
except exc.IntegrityError as e:
logging.error(e.__str__())
db.rollback()
except Exception as e:
logging.error(e.__str__())
db.rollback()
r = client.get(
f"{settings.API_V1_STR}/divisions/{division.id}/students",
headers=authentication_token_from_email(client=client,
db=db,
email=professor.email),
)
assert r.status_code == 200
assert r.json()
fetched_students = [student.get("user_id") for student in r.json()]
for student in students:
assert student.user_id in fetched_students
def test_get_student_divisions_id_normal_user(
client: TestClient, normal_user_token_headers: dict[str, str], db: Session
) -> None:
student = create_random_student(db)
course = create_random_course(db, term_id=student.term_id)
division = create_random_division(db, course_id=course.id)
division.students.append({"student": student, "batch_number": randint(1, 5)})
r = client.get(
f"{settings.API_V1_STR}/students/{student.user_id}/divisions",
headers=normal_user_token_headers,
)
assert r.status_code == 403
def test_add_division_students(client: TestClient,
superuser_token_headers: dict[str, str],
db: Session) -> None:
course = create_random_course(db)
division = create_random_division(db, course_id=course.id)
students = [
create_random_student(db,
school_id=course.term.year.school_id,
term_id=course.term_id),
create_random_student(db,
school_id=course.term.year.school_id,
term_id=course.term_id),
]
data = [student.user_id for student in students]
r = client.post(f"{settings.API_V1_STR}/divisions/{division.id}/students",
headers=superuser_token_headers,
json=data)
assert r.status_code == 207
assert r.json()
fetched_students = [student_id for student_id in r.json()["success"]]
for student in students:
assert student.user_id in fetched_students
def test_add_students_to_division_batches(db: Session) -> None:
division = create_random_division(db)
assert division
students = [
create_random_student(db, term_id=division.course.term_id),
create_random_student(db, term_id=division.course.term_id),
]
random_batch = randint(1, 5)
for student in students:
division.students.append({
"student": student,
"batch_number": random_batch
})
db.commit()
for student in students:
db.refresh(student)
assert student.divisions
assert student.divisions[0] == division
assert getattr(student,
"student_division")[0].division_id == division.id
assert getattr(student,
"student_division")[0].batch_number == random_batch
def test_get_division_batch_students_admin_with_perms(client: TestClient,
db: Session) -> None:
course = create_random_course(db)
division = create_random_division(db, course_id=course.id)
students = [
create_random_student(db,
school_id=course.term.year.school_id,
term_id=course.term_id),
create_random_student(db,
school_id=course.term.year.school_id,
term_id=course.term_id),
]
batch_number = randint(1, 5)
for student in students:
division.students.append({
"student": student,
"batch_number": batch_number
})
try:
db.commit()
except exc.IntegrityError as e:
logging.error(e.__str__())
db.rollback()
except Exception as e:
logging.error(e.__str__())
db.rollback()
perms = AdminPermissions(0)
perms["course"] = True
admin = create_random_user(db, type="admin", permissions=perms.permissions)
r = client.get(
f"{settings.API_V1_STR}/divisions/{division.id}/students/{batch_number}",
headers=authentication_token_from_email(client=client,
db=db,
email=admin.email),
)
assert r.status_code == 200
student_ids = [student.get("user_id") for student in r.json()]
for student in students:
assert student.user_id in student_ids
def test_update_students_superuser(client: TestClient, superuser_token_headers: dict[str, str], db: Session) -> None:
student = create_random_student(db)
term_id = create_random_term(db).id
data = {"term_id": term_id}
r = client.put(
f"{settings.API_V1_STR}/students/{student.user_id}",
headers=superuser_token_headers,
json=data,
)
assert r.status_code == 200
updated_student = r.json()
assert updated_student
db.refresh(student)
compare_api_and_db_query_results(api_result=updated_student, db_dict=to_json(student))
def test_get_term_students(client: TestClient,
superuser_token_headers: dict[str, str],
db: Session) -> None:
term = create_random_term(db=db)
student = create_random_student(db=db, term_id=term.id)
db.refresh(term)
assert term.students[-1] == student
r = client.get(f"{settings.API_V1_STR}/terms/{term.id}/students",
headers=superuser_token_headers)
assert r.status_code == 200
students = r.json()
assert students
for api_obj, db_obj in zip(students, term.students):
compare_api_and_db_query_results(api_result=api_obj,
db_dict=to_json(db_obj))
def test_get_student_divisions_id_admin_with_perms(client: TestClient, db: Session) -> None:
student = create_random_student(db)
course = create_random_course(db, term_id=student.term_id)
division = create_random_division(db, course_id=course.id)
division.students.append({"student": student, "batch_number": randint(1, 5)})
perms = AdminPermissions(0)
perms["student"] = True
admin = create_random_user(db, type="admin", permissions=perms.permissions)
r = client.get(
f"{settings.API_V1_STR}/students/{student.user_id}/divisions",
headers=authentication_token_from_email(client=client, email=admin.email, db=db),
)
assert r.status_code == 200
fetched_divisions = r.json()
assert fetched_divisions
assert division.id == fetched_divisions[0].get("id")
def test_get_student_me_divisions(client: TestClient, db: Session) -> None:
student = create_random_student(db)
course = create_random_course(db, term_id=student.term_id)
divisions = [create_random_division(db, course_id=course.id), create_random_division(db, course_id=course.id)]
batch_number = randint(1, 5)
for division in divisions:
division.students.append({"student": student, "batch_number": batch_number})
r = client.get(
f"{settings.API_V1_STR}/students/me/divisions",
headers=authentication_token_from_email(client=client, email=student.user.email, db=db),
)
assert r.status_code == 200
fetched_divisions = r.json()
assert fetched_divisions
assert len(fetched_divisions) == 2
for division in divisions:
if fetched_divisions[0].get("id") == division.id:
compare_api_and_db_query_results(api_result=fetched_divisions[0], db_dict=to_json(division))
else:
compare_api_and_db_query_results(api_result=fetched_divisions[1], db_dict=to_json(division))
def test_add_division_students_duplicate_students(
client: TestClient, superuser_token_headers: dict[str, str],
db: Session) -> None:
course = create_random_course(db)
division = create_random_division(db, course_id=course.id)
s = create_random_student(db,
school_id=course.term.year.school_id,
term_id=course.term_id)
students = [s, s]
data = [student.user_id for student in students]
r = client.post(f"{settings.API_V1_STR}/divisions/{division.id}/students",
headers=superuser_token_headers,
json=data)
assert r.status_code == 207
assert r.json()
db.refresh(division)
success = r.json().get("success")
assert success
assert s.user_id in [student_id for student_id in success]
errors = r.json().get("errors")
assert errors.get("student already in division")
assert s.user_id in [
student_id for student_id in errors.get("student already in division")
]
def test_create_student(db: Session) -> None:
student = create_random_student(db)
assert student
assert student.user_id
assert student.term_id
def test_remove_student(db: Session) -> None:
student = create_random_student(db)
assert student
crud.student.remove(db, id=student.user_id)
assert not crud.student.get(db, id=student.user_id)
