def test_create_division(client: TestClient, superuser_token_headers: dict[str, str], db: Session) -> None: course_id = create_random_course(db).id division_code = randint(1, 20) professor_id = create_random_professor(db).user_id data = { "course_id": course_id, "division_code": division_code, "professor_id": professor_id, } r = client.post(f"{settings.API_V1_STR}/divisions/", headers=superuser_token_headers, json=data) assert r.status_code == 200 created_division = r.json() fetched_division = crud.division.get_by_details( db, course_id=course_id, division_code=division_code, ) assert fetched_division compare_api_and_db_query_results(created_division, to_json(fetched_division)) compare_api_and_db_query_results(data, to_json(fetched_division))
def test_get_all_timeslots(client: TestClient, superuser_token_headers: dict[str, str], db: Session) -> None: timeslot = create_random_timeslot(db) r = client.get(f"{settings.API_V1_STR}/timeslots/", headers=superuser_token_headers) assert r.status_code == 200 results = r.json() assert results compare_api_and_db_query_results(api_result=results[-1], db_dict=to_json(timeslot))
def test_create_year(client: TestClient, superuser_token_headers: dict[str, str], db: Session) -> None: school_id = create_random_school(db).id start_year = datetime.now().year end_year = start_year + 1 name = random_lower_string() data = { "name": name, "school_id": school_id, "start_year": start_year, "end_year": end_year, } r = client.post(f"{settings.API_V1_STR}/years/", headers=superuser_token_headers, json=data) assert r.status_code == 200 created_year = r.json() year = crud.year.get_by_details(db, name=name, school_id=school_id, start_year=start_year, end_year=end_year) assert year compare_api_and_db_query_results(api_result=created_year, db_dict=to_json(year)) compare_api_and_db_query_results(data, created_year)
def test_create_term(client: TestClient, superuser_token_headers: dict[str, str], db: Session) -> None: name = random_lower_string() year_id = create_random_year(db=db).id start_date = datetime.now().date() end_date = start_date + timedelta(days=90) current_year_term = randint(1, 4) has_electives = choice([True, False]) data = { "name": name, "year_id": year_id, "start_date": start_date.isoformat(), "end_date": end_date.isoformat(), "current_year_term": current_year_term, "has_electives": has_electives, } r = client.post(f"{settings.API_V1_STR}/terms/", headers=superuser_token_headers, json=data) assert r.status_code == 200 created_term = r.json() fetched_term = crud.term.get_by_details( db=db, name=name, year_id=year_id, current_year_term=current_year_term, start_date=start_date, end_date=end_date, ) assert fetched_term compare_api_and_db_query_results(api_result=created_term, db_dict=to_json(fetched_term)) compare_api_and_db_query_results(data, created_term)
def test_create_course(client: TestClient, superuser_token_headers: dict[str, str], 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 data = { "name": name, "course_code": course_code, "elective_code": elective_code, "term_id": term_id, } r = client.post(f"{settings.API_V1_STR}/courses/", headers=superuser_token_headers, json=data) assert r.status_code == 200 created_course = r.json() fetched_course = crud.course.get_by_details( db, name=name, course_code=course_code, term_id=term_id, ) assert fetched_course compare_api_and_db_query_results(api_result=created_course, db_dict=to_json(fetched_course)) compare_api_and_db_query_results(data, created_course)
def test_get_timeslot_existing(client: TestClient, superuser_token_headers: dict[str, str], db: Session) -> None: timeslot = create_random_timeslot(db) r = client.get(f"{settings.API_V1_STR}/timeslots/{timeslot.id}", headers=superuser_token_headers) assert r.status_code == 200 fetched_timeslot = r.json() assert fetched_timeslot compare_api_and_db_query_results(api_result=fetched_timeslot, db_dict=to_json(timeslot))
def test_read_user_self(client: TestClient, db: Session) -> None: user = create_random_user(db, type="student") r = client.get( f"{settings.API_V1_STR}/users/{user.id}", headers=authentication_token_from_email(client=client, email=user.email, db=db), ) assert r.status_code == 200 fetched_user = r.json() compare_api_and_db_query_results(api_result=fetched_user, db_dict=to_json(user))
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_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_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_get_school_superuser(client: TestClient, superuser_token_headers: dict[str, str], db: Session) -> None: school = create_random_school(db) r = client.get(f"{settings.API_V1_STR}/schools/{school.id}", headers=superuser_token_headers) assert r.status_code == 200 fetched_school = r.json() assert fetched_school compare_api_and_db_query_results(api_result=fetched_school, db_dict=to_json(school))
def test_get_school_valid_student(client: TestClient, db: Session) -> None: school = create_random_school(db) admin_user_token_headers = authentication_token_from_email( client=client, db=db, email=random_email(), school_id=school.id) r = client.get(f"{settings.API_V1_STR}/schools/{school.id}", headers=admin_user_token_headers) assert r.status_code == 200 fetched_school = r.json() assert fetched_school compare_api_and_db_query_results(api_result=fetched_school, db_dict=to_json(school))
def test_get_existing_user(client: TestClient, superuser_token_headers: dict, db: Session) -> None: user = create_random_user(db=db, type="superuser") assert user user_id = user.id r = client.get( f"{settings.API_V1_STR}/users/{user_id}", headers=superuser_token_headers, ) assert r.status_code == 200 api_user = r.json() compare_api_and_db_query_results(api_result=api_user, db_dict=to_json(user))
def test_get_year_existing(client: TestClient, superuser_token_headers: dict[str, str], db: Session) -> None: year = create_random_year(db) r = client.get(f"{settings.API_V1_STR}/years/{year.id}", headers=superuser_token_headers) assert r.status_code == 200 fetched_year = r.json() assert fetched_year compare_api_and_db_query_results(api_result=fetched_year, db_dict=to_json(year))
def test_get_lecture_superuser(client: TestClient, superuser_token_headers: dict[str, str], db: Session) -> None: lecture = create_random_lecture(db) r = client.get(f"{settings.API_V1_STR}/lectures/{lecture.id}", headers=superuser_token_headers) assert r.status_code == 200 fetched_lecture = r.json() assert fetched_lecture compare_api_and_db_query_results(api_result=fetched_lecture, db_dict=to_json(lecture))
def test_get_course_existing(client: TestClient, superuser_token_headers: dict[str, str], db: Session) -> None: course = create_random_course(db) r = client.get(f"{settings.API_V1_STR}/courses/{course.id}", headers=superuser_token_headers) assert r.status_code == 200 fetched_course = r.json() assert fetched_course compare_api_and_db_query_results(api_result=fetched_course, db_dict=to_json(course))
def test_update_user_superuser(client: TestClient, superuser_token_headers: dict[str, str], db: Session) -> None: user = create_random_user(db, type="student") full_name = random_lower_string() data = {"full_name": full_name} r = client.put( f"{settings.API_V1_STR}/users/{user.id}", headers=superuser_token_headers, json=data, ) assert r.status_code == 200 updated_user = r.json() db.refresh(user) compare_api_and_db_query_results(api_result=updated_user, db_dict=to_json(user))
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_user_new_email(client: TestClient, superuser_token_headers: dict, db: Session) -> None: username = random_email() password = random_password() data = {"email": username, "password": password, "type": "superuser"} r = client.post( f"{settings.API_V1_STR}/users/", headers=superuser_token_headers, json=data, ) assert r.status_code == 200 created_user = r.json() user = crud.user.get_by_email(db, email=username) assert user compare_api_and_db_query_results(api_result=created_user, db_dict=to_json(user))
def test_get_all_professors(client: TestClient, superuser_token_headers: dict[str, str], db: Session) -> None: school = create_random_school(db) school_professor = create_random_user(db=db, type="professor", school_id=school.id) r = client.get(f"{settings.API_V1_STR}/schools/{school.id}/professors", headers=superuser_token_headers) assert r.status_code == 200 fetched_professors = r.json() assert fetched_professors compare_api_and_db_query_results(api_result=fetched_professors[-1], db_dict=to_json(school_professor))
def test_get_lecture_admin(client: TestClient, db: Session) -> None: lecture = create_random_lecture(db) perms = AdminPermissions(0) perms["school"] = True admin = create_random_user(db, "admin", permissions=perms.permissions) admin_user_token_headers = authentication_token_from_email( client=client, db=db, email=admin.email, user_type="admin") r = client.get(f"{settings.API_V1_STR}/lectures/{lecture.id}", headers=admin_user_token_headers) assert r.status_code == 200 fetched_lecture = r.json() assert fetched_lecture compare_api_and_db_query_results(api_result=fetched_lecture, db_dict=to_json(lecture))
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_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_update_timeslot(client: TestClient, superuser_token_headers: dict[str, str], db: Session) -> None: timeslot = create_random_timeslot(db) start_time = datetime.now().time() end_time = (datetime.now() + timedelta(hours=1)).time() school_id = create_random_school(db).id data = { "start_time": start_time.isoformat(), "end_time": end_time.isoformat(), "school_id": school_id, } r = client.put(f"{settings.API_V1_STR}/timeslots/{timeslot.id}", headers=superuser_token_headers, json=data) fetched_timeslot = r.json() db.refresh(timeslot) assert fetched_timeslot compare_api_and_db_query_results(api_result=fetched_timeslot, db_dict=to_json(timeslot))
def test_update_course(client: TestClient, superuser_token_headers: dict[str, str], db: Session) -> None: course = create_random_course(db) assert course.name name = random_lower_string() data = {"name": name} r = client.put(f"{settings.API_V1_STR}/courses/{course.id}", headers=superuser_token_headers, json=data) fetched_course = r.json() db.refresh(course) assert fetched_course compare_api_and_db_query_results(api_result=fetched_course, db_dict=to_json(course))
def test_create_school(client: TestClient, superuser_token_headers: dict[str, str], db: Session) -> None: name = random_lower_string() head = random_lower_string() data = {"name": name, "head": head} r = client.post(f"{settings.API_V1_STR}/schools/", headers=superuser_token_headers, json=data) assert r.status_code == 200 created_school = r.json() school = crud.school.get_by_name(db, name=name) assert school compare_api_and_db_query_results(api_result=created_school, db_dict=to_json(school))
def test_update_lecture(client: TestClient, superuser_token_headers: dict[str, str], db: Session) -> None: lecture = create_random_lecture(db) new_timeslot = create_random_timeslot(db) data = {"time_slot_id": new_timeslot.id} r = client.put(f"{settings.API_V1_STR}/lectures/{lecture.id}", headers=superuser_token_headers, json=data) assert r.status_code == 200 fetched_lecture = r.json() db.refresh(lecture) assert fetched_lecture compare_api_and_db_query_results(api_result=fetched_lecture, db_dict=to_json(lecture))
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))