def test_delete_note(schema, success): context = MagicMock() note_id = uuid4() error = Err(fake.pystr()) context.user = fake_instructor() context.api.meeting_api.delete_note.return_value = Ok( note_id) if success else error query = """ mutation deleteNote($noteId: UUID!) { deleteNote(noteId: $noteId) { noteId } } """ result = schema.execute(query, context=context, variables={"noteId": str(note_id)}) if success: assert not result.errors assert result.data["deleteNote"] == {"noteId": str(note_id)} else: assert error.unwrap_err() in str(result.errors) context.api.meeting_api.delete_note.assert_called_once_with( note_id, context.user)
def test_duplicate(self, instructor_persistence): instructor = fake_instructor() instructor_persistence.get_instructor = MagicMock(return_value=Some(instructor)) assert ( instructor_persistence.create_instructor(instructor, "aaaa").unwrap_err() == f"Instructor {instructor} already exists" )
def fake_section(course=None, year=None, semester=None) -> Section: course = course or fake_course() year = year or int(fake.year()) semester = semester or choice(list(Semester)) section_code = fake.pystr() instructor = fake_instructor() num_students = fake.pyint() return Section(course, year, semester, section_code, instructor, num_students)
def test_delete_note_not_exist(meeting_api): note_id = uuid4() author = fake_instructor() meeting_api.meeting_persistence.get_note.return_value = NONE assert (f"Note with ID: '{note_id}'" in meeting_api.delete_note(note_id, author).unwrap_err()) meeting_api.meeting_persistence.get_note.assert_called_once_with(note_id) meeting_api.meeting_persistence.get_meeting.assert_not_called()
def fake_comment(author=None) -> Iterator[Comment]: while True: _author = author or fake_instructor() yield Comment( comment_id=uuid4(), meeting_id=uuid4(), author=_author, time_stamp=int(time.time()), content_text=fake.pystr(), )
def test_delete_note_no_meeting(meeting_api): note = next(fake_note()) author = fake_instructor() meeting_api.meeting_persistence.get_note.return_value = Some(note) meeting_api.meeting_persistence.get_meeting.return_value = NONE assert (f"Meeting with ID: '{note.meeting_id}'" in meeting_api.delete_note(note.note_id, author).unwrap_err()) meeting_api.meeting_persistence.get_note.assert_called_once_with( note.note_id) meeting_api.meeting_persistence.get_meeting.assert_called_once_with( note.meeting_id)
def test_delete_note_wrong_author(meeting_api): note = next(fake_note()) meeting = next(fake_meeting()) author = fake_instructor() meeting_api.meeting_persistence.get_note.return_value = Some(note) meeting_api.meeting_persistence.get_meeting.return_value = Some(meeting) assert "not belong" in meeting_api.delete_note(note.note_id, author).unwrap_err() meeting_api.meeting_persistence.get_note.assert_called_once_with( note.note_id) meeting_api.meeting_persistence.get_meeting.assert_called_once_with( note.meeting_id)
def fake_meeting() -> Iterator[Meeting]: while True: start_time = fake.date_time() yield Meeting( meeting_id=uuid4(), office_hour_id=uuid4(), index=abs(fake.pyint()), instructor=fake_instructor(), student=fake_student(), notes=[], comments=[], start_time=int(start_time.timestamp()), )
def test_query_one(self, schema): meeting = next(fake_meeting()) meeting.comments.append(next(fake_comment(fake_student()))) meeting.comments.append(next(fake_comment(fake_instructor()))) context = MagicMock() context.api.meeting_api.get_meeting.return_value = Some(meeting) result = schema.execute( self.query_one, context=context, variables={"meetingId": str(meeting.meeting_id)}, ) assert not result.errors context.api.meeting_api.get_meeting.assert_called_once_with( meeting.meeting_id) assert result.data["meeting"]["meetingId"] == str(meeting.meeting_id)
def test_success(self, instructor_persistence): instructor = fake_instructor() assert ( instructor_persistence.create_instructor(instructor, "aaaa").unwrap() == instructor ) assert ( instructor_persistence.get_instructor(instructor.user_name).unwrap() == instructor ) assert ( instructor_persistence.get_password_hash(instructor.user_name).unwrap() == "aaaa" ) instructor_persistence.delete_instructor(instructor)
def test_verify_token(instructor_api, instructor_found): token = fake.sha256() instructor = fake_instructor() instructor_api.jwt_authenticator.verify_token.return_value = Ok( {"id": instructor.user_name}) if instructor_found: instructor_api.get_instructor = MagicMock( return_value=Some(instructor)) assert instructor_api.verify_instructor_by_token(token) == Ok( instructor) else: instructor_api.get_instructor = MagicMock(return_value=NONE) assert instructor_api.verify_instructor_by_token(token) == Err( "UNAUTHORIZED - Could not get instructor") instructor_api.jwt_authenticator.verify_token.assert_called_once_with( token) instructor_api.get_instructor.assert_called_once_with(instructor.user_name)
def test_update_hash(self, instructor_persistence): instructor = fake_instructor() instructor_persistence.create_instructor(instructor, "aaaa") assert ( instructor_persistence.get_password_hash(instructor.user_name).unwrap() == "aaaa" ) assert ( instructor_persistence.update_password_hash( instructor.user_name, "bbbb" ).unwrap() is None ) assert ( instructor_persistence.get_password_hash(instructor.user_name).unwrap() == "bbbb" ) instructor_persistence.delete_instructor(instructor)
def test_create_instructor(instructor_api, success): instructor = fake_instructor() password = fake.pystr() password_hash = fake.sha256() error = Err(fake.pystr()) instructor_api.password_authenticator.crypto_context.hash = MagicMock( return_value=password_hash) instructor_api.instructor_persistence.create_instructor.return_value = ( Ok(instructor) if success else error) result = instructor_api.create_instructor(instructor.first_name, instructor.last_name, instructor.user_name, password) if success: assert result == Ok(instructor) else: assert result == error instructor_api.password_authenticator.crypto_context.hash.assert_called_once_with( password) instructor_api.instructor_persistence.create_instructor.assert_called_once_with( instructor, password_hash)
from core.authentication.token_auth import JwtAuthenticator from core.persistence.instructor_persistence import InstructorPersistence from core.tests.generation import fake from core.tests.generation.fake_user import fake_instructor @pytest.fixture() def instructor_api(): return InstructorApi( MagicMock(InstructorPersistence), MagicMock(PasswordAuthenticator), MagicMock(JwtAuthenticator), ) @pytest.mark.parametrize("expected_instructor", [None, fake_instructor()]) def test_get_instructor(instructor_api, expected_instructor): instructor_api.instructor_persistence.get_instructor = MagicMock( return_value=maybe(expected_instructor)) user_name = expected_instructor.user_name if expected_instructor else fake.pystr( ) assert instructor_api.get_instructor(user_name) == maybe( expected_instructor) instructor_api.instructor_persistence.get_instructor.called_once_with( user_name) @pytest.mark.parametrize("success", [True, False]) def test_create_instructor(instructor_api, success): instructor = fake_instructor() password = fake.pystr()
class TestMeetingQuery: meeting_fragment = """ fragment meetingDetails on Meeting { meetingId officeHourId index instructor { userName firstName lastName } student { studentNumber firstName lastName } notes { noteId meetingId timeStamp contentText } comments { commentId meetingId author { ... on Instructor { userName firstName lastName } ... on Student { studentNumber firstName lastName } } timeStamp contentText } startTime } """ query_one = (""" query getMeeting($meetingId: UUID!) { meeting(meetingId: $meetingId) { ... meetingDetails } } """ + meeting_fragment) query_upcoming = (""" query getUpcoming { upcomingMeetings { ... meetingDetails } } """ + meeting_fragment) def test_query_one(self, schema): meeting = next(fake_meeting()) meeting.comments.append(next(fake_comment(fake_student()))) meeting.comments.append(next(fake_comment(fake_instructor()))) context = MagicMock() context.api.meeting_api.get_meeting.return_value = Some(meeting) result = schema.execute( self.query_one, context=context, variables={"meetingId": str(meeting.meeting_id)}, ) assert not result.errors context.api.meeting_api.get_meeting.assert_called_once_with( meeting.meeting_id) assert result.data["meeting"]["meetingId"] == str(meeting.meeting_id) @pytest.mark.parametrize("user", [fake_instructor(), fake_student()]) @pytest.mark.parametrize("amount", [0, 10]) def test_query_upcoming(self, schema, user, amount): meetings = [ meeting for meeting, _ in zip(fake_meeting(), range(amount)) ] context = MagicMock() context.user = user if isinstance(user, Instructor): api_method = context.api.meeting_api.get_meetings_of_instructor user_id = user.user_name else: api_method = context.api.meeting_api.get_meetings_of_student user_id = user.student_number api_method.return_value = meetings result = schema.execute(self.query_upcoming, context=context) assert not result.errors for gql_result, meeting in zip(result.data["upcomingMeetings"], meetings): assert gql_result["meetingId"] == str(meeting.meeting_id) api_method.assert_called_once_with(user_id)
@pytest.fixture() def meeting_api(): return MeetingApi(MagicMock(MeetingPersistence)) @pytest.mark.parametrize("user_type", ["instructor", "student"]) def test_check_meeting_user(meeting_api, user_type): meeting = next(fake_meeting()) user = meeting.instructor if user_type == "instructor" else meeting.student meeting_api.meeting_persistence.get_meeting.return_value = Some(meeting) assert meeting_api._check_meeting_user(meeting.meeting_id, user, "").is_ok meeting_api.meeting_persistence.get_meeting.assert_called_once_with( meeting.meeting_id) @pytest.mark.parametrize("user", [fake_student(), fake_instructor()]) def test_check_meeting_user_not_permitted(meeting_api, user): meeting = next(fake_meeting()) meeting_api.meeting_persistence.get_meeting.return_value = Some(meeting) error = fake.pystr() assert (meeting_api._check_meeting_user(meeting.meeting_id, user, error).unwrap_err() == error) meeting_api.meeting_persistence.get_meeting.assert_called_once_with( meeting.meeting_id) @pytest.mark.parametrize("user", [fake_student(), fake_instructor()]) def test_check_meeting_user_not_found(meeting_api, user): id_ = uuid4() meeting_api.meeting_persistence.get_meeting.return_value = NONE error = fake.pystr()