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()
