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_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_update_division(db: Session) -> None:
professor_id = create_random_professor(db).user_id
division = create_random_division(db)
assert division
updated_division = crud.division.update(
db, db_obj=division, obj_in=DivisionUpdate(professor_id=professor_id))
assert updated_division.professor_id == professor_id
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_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_delete_division(client: TestClient,
superuser_token_headers: dict[str, str],
db: Session) -> None:
division = create_random_division(db)
r = client.delete(f"{settings.API_V1_STR}/divisions/{division.id}",
headers=superuser_token_headers)
assert r.status_code == 200
deleted_division = crud.division.get(db, id=division.id)
assert deleted_division is None
def test_get_division_students_admin_without_perms(
client: TestClient, admin_user_token_headers: dict[str, str],
db: Session) -> None:
division = create_random_division(db)
r = client.get(
f"{settings.API_V1_STR}/divisions/{division.id}/students",
headers=admin_user_token_headers,
)
assert r.status_code == 403
def test_get_division_batch_students_normal_user(
client: TestClient, normal_user_token_headers: dict[str, str],
db: Session) -> None:
division = create_random_division(db)
r = client.get(
f"{settings.API_V1_STR}/divisions/{division.id}/students/0",
headers=normal_user_token_headers,
)
assert r.status_code == 403
def test_remove_division_nonexisting_student(client: TestClient,
superuser_token_headers: dict[
str, str],
db: Session) -> None:
division = create_random_division(db)
r = client.delete(
f"{settings.API_V1_STR}/divisions/{division.id}/students/{generate_uuid()}",
headers=superuser_token_headers)
assert r.status_code == 404
def test_get_division_existing(client: TestClient,
superuser_token_headers: dict[str, str],
db: Session) -> None:
division = create_random_division(db)
r = client.get(f"{settings.API_V1_STR}/divisions/{division.id}",
headers=superuser_token_headers)
assert r.status_code == 200
fetched_division = r.json()
assert fetched_division
compare_api_and_db_query_results(fetched_division, to_json(division))
def test_get_all_divisions(client: TestClient,
superuser_token_headers: dict[str, str],
db: Session) -> None:
division = create_random_division(db)
r = client.get(f"{settings.API_V1_STR}/divisions/",
headers=superuser_token_headers)
assert r.status_code == 200
results = r.json()
assert results
compare_api_and_db_query_results(results[-1], to_json(division))
def test_division_by_details(db: Session) -> None:
division = create_random_division(db)
assert division.course_id
assert division.division_code
fetched_division = crud.division.get_by_details(
db,
course_id=division.course_id,
division_code=division.division_code,
)
assert fetched_division
assert fetched_division.id == division.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_create_division(db: Session) -> None:
course_id = create_random_course(db).id
division_code = randint(1, 20)
professor_id = create_random_professor(db).user_id
division = create_random_division(db,
course_id=course_id,
division_code=division_code,
professor_id=professor_id)
assert division
assert division.course_id == course_id
assert division.division_code == division_code
assert division.professor_id == professor_id
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_read_professor_divisions_by_id_superuser(
client: TestClient, superuser_token_headers: dict[str, str],
db: Session) -> None:
professor = create_random_user(db, type="professor")
division = create_random_division(db, professor_id=professor.id)
r = client.get(
f"{settings.API_V1_STR}/professors/{professor.id}/divisions",
headers=superuser_token_headers,
)
assert r.status_code == 200
divisions = r.json()
compare_api_and_db_query_results(api_result=divisions[-1],
db_dict=to_json(division))
def test_create_division_existing(client: TestClient,
superuser_token_headers: dict[str, str],
db: Session) -> None:
division = create_random_division(db)
data = {
"course_id": division.course_id,
"division_code": division.division_code,
"professor_id": division.professor_id,
}
r = client.post(f"{settings.API_V1_STR}/divisions/",
headers=superuser_token_headers,
json=data)
assert r.status_code == 409
def test_add_division_students_not_a_user(client: TestClient,
superuser_token_headers: dict[str,
str],
db: Session) -> None:
division = create_random_division(db)
new_user_id = generate_uuid()
data = [new_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("not a user")[0] == new_user_id
def test_read_professor_divisions_by_id_normal_professor_fetch_self(
client: TestClient, db: Session) -> None:
professor = create_random_user(db, type="professor")
division = create_random_division(db, professor_id=professor.id)
r = client.get(
f"{settings.API_V1_STR}/professors/{professor.id}/divisions",
headers=authentication_token_from_email(client=client,
email=professor.email,
db=db),
)
assert r.status_code == 200
divisions = r.json()
compare_api_and_db_query_results(api_result=divisions[-1],
db_dict=to_json(division))
def test_update_division(client: TestClient,
superuser_token_headers: dict[str, str],
db: Session) -> None:
division = create_random_division(db)
assert division.professor_id
professor_id = create_random_professor(db).user_id
data = {"professor_id": professor_id}
r = client.put(f"{settings.API_V1_STR}/divisions/{division.id}",
headers=superuser_token_headers,
json=data)
fetched_division = r.json()
db.refresh(division)
assert fetched_division
compare_api_and_db_query_results(fetched_division, to_json(division))
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_read_professor_divisions_by_id_admin_with_permissions(
client: TestClient, db: Session) -> None:
professor = create_random_user(db, type="professor")
division = create_random_division(db, professor_id=professor.id)
admin_perms = AdminPermissions(0)
admin_perms["professor"] = True
admin_with_perms = create_random_user(db,
type="admin",
permissions=admin_perms.permissions)
r = client.get(
f"{settings.API_V1_STR}/professors/{professor.id}/divisions",
headers=authentication_token_from_email(client=client,
email=admin_with_perms.email,
db=db),
)
assert r.status_code == 200
divisions = r.json()
compare_api_and_db_query_results(api_result=divisions[-1],
db_dict=to_json(division))
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_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_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_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_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")
]
