def test_get_all_terms(client: TestClient, superuser_token_headers: dict[str,
str],
db: Session) -> None:
create_random_term(db=db)
r = client.get(f"{settings.API_V1_STR}/terms/",
headers=superuser_token_headers)
assert r.status_code == 200
results = r.json()
assert results
def test_add_division_students_different_term(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_different_term = create_random_student(
db,
school_id=course.term.year.school_id,
term_id=create_random_term(db).id)
data.append(student_different_term.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(
"different terms")[0] == student_different_term.user_id
for student in students:
assert student.user_id in response.get("success")
def test_add_term_students_no_student_object(client: TestClient,
superuser_token_headers: dict[
str, str],
db: Session) -> None:
term = create_random_term(db)
students = [
create_random_user(db, type="student", school_id=term.year.school_id),
create_random_user(db, type="student", school_id=term.year.school_id),
]
data = [user.id for user in students]
student_no_object = create_random_user(db,
type="student",
school_id=term.year.school_id)
crud.student.remove(db, id=student_no_object.id)
data.append(student_no_object.id)
r = client.post(f"{settings.API_V1_STR}/terms/{term.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.id
for user in students:
student = crud.student.get(db, id=user.id)
assert student
assert student.user_id in response.get("success")
assert student.term_id == term.id
def test_update_user_professor(db: Session) -> None:
professor = create_random_professor(db)
assert professor
term = create_random_term(db)
professor_update = ProfessorUpdate(user_id=professor.user_id, term_id=term.id)
crud.professor.update(db, db_obj=professor, obj_in=professor_update)
user_2 = crud.professor.get(db, id=professor.user_id)
assert user_2
def test_remove_term_nonexisting_student(client: TestClient,
superuser_token_headers: dict[str,
str],
db: Session) -> None:
term = create_random_term(db)
r = client.delete(
f"{settings.API_V1_STR}/terms/{term.id}/students/{generate_uuid()}",
headers=superuser_token_headers)
assert r.status_code == 404
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_nonexisting_student(client: TestClient, superuser_token_headers: dict[str, str], db: Session) -> None:
term_id = create_random_term(db).id
data = {"term_id": term_id}
r = client.put(
f"{settings.API_V1_STR}/students/{generate_uuid()}",
headers=superuser_token_headers,
json=data,
)
assert r.status_code == 404
def test_delete_term(client: TestClient, superuser_token_headers: dict[str,
str],
db: Session) -> None:
term = create_random_term(db=db)
r = client.delete(f"{settings.API_V1_STR}/terms/{term.id}",
headers=superuser_token_headers)
assert r.status_code == 200
deleted_term = crud.term.get(db=db, id=term.id)
assert deleted_term is None
def test_update_user_professor_with_dict(db: Session) -> None:
professor = create_random_professor(db)
assert professor
term = create_random_term(db)
professor_update = {"user_id": professor.user_id, "term_id": term.id}
crud.professor.update(db, db_obj=professor, obj_in=professor_update)
professor_2 = crud.professor.get(db, id=professor.user_id)
assert professor_2
assert professor_2.user_id == professor.user_id
def test_update_term(db: Session) -> None:
term = create_random_term(db=db, is_active=False)
assert term
end_date = term.start_date + timedelta(days=randint(2 * 30, 6 * 30))
updated_term = crud.term.update(db=db,
db_obj=term,
obj_in=TermUpdate(end_date=end_date,
is_active=True))
assert updated_term.end_date == end_date
assert updated_term.is_active
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_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_get_term_existing(client: TestClient,
superuser_token_headers: dict[str, str],
db: Session) -> None:
term = create_random_term(db=db)
r = client.get(f"{settings.API_V1_STR}/terms/{term.id}",
headers=superuser_token_headers)
assert r.status_code == 200
fetched_term = r.json()
assert fetched_term
compare_api_and_db_query_results(api_result=fetched_term,
db_dict=to_json(term))
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 create_random_student(db: Session,
term_id: Optional[str] = None,
school_id: Optional[str] = None) -> Student:
user = create_random_user(db, type="student", school_id=school_id)
if term_id and crud.term.get(db, id=term_id):
student_in = StudentUpdate(user_id=user.id, term_id=term_id)
else:
term = create_random_term(db)
student_in = StudentUpdate(user_id=user.id, term_id=term.id)
student = crud.student.get(db, id=user.id)
assert student
return crud.student.update(db, db_obj=student, obj_in=student_in)
def test_create_term(db: Session) -> None:
name = random_lower_string()
start_date = datetime.now().date()
end_date = (datetime.now() + timedelta(days=90)).date()
term = create_random_term(db=db,
name=name,
start_date=start_date,
end_date=end_date,
is_active=False)
assert term
assert term.name == name
assert term.start_date == start_date
assert term.end_date == end_date
assert not term.is_active
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_create_course(db: Session) -> None:
name = random_lower_string()
course_code = random_lower_string()[:20]
elective_code = random_lower_string()[:20]
term_id = create_random_term(db).id
course = create_random_course(db,
name=name,
course_code=course_code,
elective_code=elective_code,
term_id=term_id)
assert course
assert course.name == name
assert course.course_code == course_code
assert course.elective_code == elective_code
assert course.term_id == term_id
def test_create_term_existing(client: TestClient,
superuser_token_headers: dict[str, str],
db: Session) -> None:
term = create_random_term(db=db)
data = {
"name": term.name,
"year_id": term.year_id,
"start_date": term.start_date.isoformat(),
"end_date": term.end_date.isoformat() if term.end_date else None,
"current_year_term": term.current_year_term,
"has_electives": term.has_electives,
}
r = client.post(f"{settings.API_V1_STR}/terms/",
headers=superuser_token_headers,
json=data)
assert r.status_code == 409
def test_get_by_details(db: Session) -> None:
term = create_random_term(db=db)
assert term.name
assert term.year_id
assert term.current_year_term
assert term.start_date
assert term.end_date
fetched_term = crud.term.get_by_details(
db=db,
name=term.name,
year_id=term.year_id,
current_year_term=term.current_year_term,
start_date=term.start_date,
end_date=term.end_date,
)
assert fetched_term
assert fetched_term.id == term.id
def test_add_term_students_duplicate(client: TestClient,
superuser_token_headers: dict[str, str],
db: Session) -> None:
term = create_random_term(db)
s = create_random_user(db, type="student", school_id=term.year.school_id)
students = [s, s]
data = [user.id for user in students]
r = client.post(f"{settings.API_V1_STR}/terms/{term.id}/students",
headers=superuser_token_headers,
json=data)
assert r.status_code == 207
assert r.json()
assert s.id in [student_id for student_id in r.json()["success"]]
student = crud.student.get(db, id=s.id)
assert student
assert student.term_id == term.id
assert s.id in [
student_id
for student_id in r.json().get("errors").get("student already in term")
]
def test_add_term_students(client: TestClient,
superuser_token_headers: dict[str, str],
db: Session) -> None:
term = create_random_term(db)
students = [
create_random_user(db, type="student", school_id=term.year.school_id),
create_random_user(db, type="student", school_id=term.year.school_id),
]
data = [user.id for user in students]
r = client.post(f"{settings.API_V1_STR}/terms/{term.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 user in students:
assert user.id in fetched_students
student = crud.student.get(db, id=user.id)
assert student
assert student.term_id == term.id
def test_remove_term_student(client: TestClient,
superuser_token_headers: dict[str, str],
db: Session) -> None:
term = create_random_term(db)
students = [
create_random_user(db, type="student", school_id=term.year.school_id),
create_random_user(db, type="student", school_id=term.year.school_id),
]
for user in students:
student = crud.student.get(db, user.id)
assert student
crud.student.update(db,
db_obj=student,
obj_in=StudentUpdate(term_id=term.id))
r = client.delete(
f"{settings.API_V1_STR}/terms/{term.id}/students/{students[0].id}",
headers=superuser_token_headers)
assert r.status_code == 200
updated_student = r.json()
assert updated_student["user_id"] == students[0].id
assert updated_student["term_id"] is None
def test_update_term(client: TestClient, superuser_token_headers: dict[str,
str],
db: Session) -> None:
term = create_random_term(db=db)
assert term.start_date
assert term.end_date
start_date = term.start_date - timedelta(days=6 * 30)
end_date = term.end_date - timedelta(days=6 * 30)
data = {
"start_date": start_date.isoformat(),
"end_date": end_date.isoformat(),
"is_active": not term.is_active,
}
r = client.put(f"{settings.API_V1_STR}/terms/{term.id}",
headers=superuser_token_headers,
json=data)
fetched_term = r.json()
db.refresh(term)
assert fetched_term
compare_api_and_db_query_results(api_result=fetched_term,
db_dict=to_json(term))
