def test_ok_err(ok): res = Result.Ok(1) if ok else Result.Err(1) if ok: assert res.ok() == Some(1) assert res.err() == NONE else: assert res.ok() == NONE assert res.err() == Some(1)
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 find_job(self, worker, duration: int = None, radius=None, latitude=None, longitude=None) -> Option['Request']: has_radius = not (radius is None or latitude is None or longitude is None) with self.request_mutex: for candidate in self.pending_requests: if duration is not None and candidate.duration.total_seconds( ) > duration: continue if has_radius and haversine( (candidate.latitude, candidate.longitude), (latitude, longitude)) > radius: continue if candidate.customer == worker: continue found = candidate self.pending_requests = deque( filter(lambda r: r.id != found.id, self.pending_requests)) break else: return NONE with self.pair_mutex: self.paired_requests[found.id] = worker assert found is not None found.assigned_to = worker found.save() return Some(found)
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)
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 find_worker(self, request) -> Option['User']: if request.id in self.paired_requests: with self.pair_mutex: worker = self.paired_requests[request.id] del self.paired_requests[request.id] return Some(worker) return NONE
def callback(self, value): self.semaphore.acquire() self.cache = Some(value) while (len(self.subscribers) > 0): sub = self.subscribers.pop(0) t = threading.Thread(target=sub, args=[value]) t.start() self.semaphore.release()
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)
def test_delete_note(meeting_api, success): note = next(fake_note()) meeting = next(fake_meeting()) error = Err(fake.pystr()) meeting_api.meeting_persistence.get_note.return_value = Some(note) meeting_api.meeting_persistence.get_meeting.return_value = Some(meeting) meeting_api.meeting_persistence.delete_note.return_value = (Ok( note.note_id) if success else error) result = meeting_api.delete_note(note.note_id, meeting.instructor) if success: assert result.unwrap() == note.note_id else: assert result == error 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_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_query_one(self, schema): self.before_each() fake_domain = self.fake_domain() identity = self.get_identity(fake_domain) self.mock_get_method().return_value = Some(fake_domain) result = schema.execute(self.query, variables=self.variables(identity), context=self.mock_context) assert not result.errors assert result.data == self.to_graphql(fake_domain) self.mock_get_method().assert_called_once_with(identity)
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 load_json(string: AnyStr) -> Option[Json]: """ Try to load a JSON string Args: string: The string to be loaded Returns: Some(json) if the load is successful NONE otherwise """ try: js = json.loads(string) except (TypeError, json.JSONDecodeError): return NONE return Some(js)
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_create_section(schema, mock_context, create_section_query, supply_instructor): context, course_api, instructor_api = mock_context section = fake_section() if supply_instructor: instructor_api.get_instructor = MagicMock( return_value=Some(section.taught_by)) else: context.user = section.taught_by course_api.create_section = MagicMock(return_value=Ok(section)) variables = section_input(section) if supply_instructor: variables["sectionInput"]["taughtBy"] = section.taught_by.user_name result = schema.execute(create_section_query, variables=variables, context=context) assert not result.errors assert result.data == { "createSection": { "course": { "courseCode": section.course.course_code }, "year": section.year, "semester": section.semester.name, "taughtBy": { "userName": section.taught_by.user_name, "firstName": section.taught_by.first_name, "lastName": section.taught_by.last_name, }, "numStudents": section.num_students, "sectionCode": section.section_code, } } course_api.create_section.assert_called_once_with( section.course, section.year, section.semester, section.section_code, section.taught_by, section.num_students, )
def validate_int(x) -> Option[int]: """ Try to convert some value to a int Args: x: The value Returns: Some(int) if the conversion is successful NONE otherwise """ if isinstance(x, (str, int)): try: parsed_int = int(x) except (TypeError, ValueError): return NONE else: return Some(parsed_int) return NONE
def validate_bool(x) -> Option[bool]: if str(x).lower() == 'true': return Some(True) elif str(x).lower() == 'false': return Some(False) return NONE
import pytest from option import NONE, Option, Some, maybe from tests.conftest import parametrize @parametrize('is_some', [True, False]) def test_no_init(is_some): with pytest.raises(TypeError): if is_some: Option(1, True) else: Option(None, False) @parametrize('obj', [Option.Some(1), Some(1)]) def test_some(obj): assert obj.is_some is True assert obj.is_none is False assert bool(obj) assert obj._val == 1 @parametrize('obj', [Option.NONE(), NONE]) def test_none(obj): assert obj.is_some is False assert obj.is_none is True assert bool(obj) is False assert obj._val is None
def test_create_officehour(schema, success): context = MagicMock() officehour = fake_officehour() error = Err(fake.pystr()) context.api.course_api.get_section.return_value = Some(officehour.section) context.api.course_api.create_officehour.return_value = ( Ok(officehour) if success else error) query = """ mutation createOfficeHour( $sectionInput: SectionInput!, $startingHour: Int!, $weekday: Weekday! ) { createOfficeHour( sectionInput: $sectionInput, startingHour: $startingHour, weekday: $weekday ) { officeHourId section { sectionCode } startingHour weekday meetings { meeting { meetingId } } } } """ variables = { "sectionInput": { "course": { "courseCode": officehour.section.course.course_code }, "year": officehour.section.year, "semester": officehour.section.semester.name, "sectionCode": officehour.section.section_code, "taughtBy": officehour.section.taught_by.user_name, "numStudents": officehour.section.num_students, }, "startingHour": officehour.starting_hour, "weekday": officehour.weekday.name, } result = schema.execute(query, context=context, variables=variables) if success: assert not result.errors create_officehour = result.data["createOfficeHour"] assert create_officehour["officeHourId"] == str( officehour.office_hour_id) assert (create_officehour["section"]["sectionCode"] == officehour.section.section_code) assert create_officehour["weekday"] == officehour.weekday.name assert create_officehour["startingHour"] == officehour.starting_hour for slot, meeting in zip(create_officehour["meetings"], officehour.meetings): if not slot["meeting"]: assert not meeting else: assert slot["meeting"]["meetingId"] == str(meeting.meeting_id) else: assert error.unwrap_err() in str(result.errors) context.api.course_api.create_officehour.assert_called_once_with( officehour.section, officehour.starting_hour, officehour.weekday)
meeting.meeting_id) @pytest.mark.parametrize("user", [fake_instructor(), fake_student()]) def test_delete_meeting_fail_user_check(meeting_api, user): meeting = next(fake_meeting()) error = Err(fake.pystr()) meeting_api._check_meeting_user = MagicMock(return_value=error) assert meeting_api.delete_meeting(meeting.meeting_id, user) == error meeting_api.meeting_persistence.delete_meeting.assert_not_called() meeting_api._check_meeting_user.assert_called_once_with( meeting.meeting_id, user, "Cannot delete meeting that you are not a part of") @pytest.mark.parametrize("expected", [Some(next(fake_meeting())), NONE]) def test_get_meeting(meeting_api, expected): meeting_id = expected.unwrap().meeting_id if expected else uuid4() meeting_api.meeting_persistence.get_meeting.return_value = expected assert meeting_api.get_meeting(meeting_id) == expected meeting_api.meeting_persistence.get_meeting.assert_called_once_with( meeting_id) meeting_api.meeting_persistence.delete_meeting.assert_not_called() def test_get_meetings_of_instructor(meeting_api): user_name = fake.pystr() expected = [meeting for meeting, _ in zip(fake_meeting(), range(10))] meeting_api.meeting_persistence.get_meetings_of_instructor.return_value = expected assert meeting_api.get_meetings_of_instructor(user_name) == expected meeting_api.meeting_persistence.get_meetings_of_instructor.assert_called_once_with(
course_api = CourseApi(mock_course_presistence) mock_course_presistence.query_courses = MagicMock(return_value=expected) assert course_api.query_courses(filters) == expected mock_course_presistence.query_courses.assert_called_once_with(filters) @pytest.mark.parametrize("filters,expected", [(None, list_fakes(fake_section, 5))]) def test_query_sections(mock_course_presistence, filters, expected): course_api = CourseApi(mock_course_presistence) mock_course_presistence.query_sections = MagicMock(return_value=expected) assert course_api.query_sections(filters) == expected mock_course_presistence.query_sections.assert_called_once_with(filters) @pytest.mark.parametrize("expected", [NONE, Some(fake_course())]) def test_get_course(mock_course_presistence, expected): course_api = CourseApi(mock_course_presistence) mock_course_presistence.get_course = MagicMock(return_value=expected) course_code = expected.map_or(lambda c: c.course_code, None) assert course_api.get_course(course_code) == expected mock_course_presistence.get_course.assert_called_once_with(course_code) @pytest.mark.parametrize("expected", [NONE, Some(fake_section())]) def test_get_section(mock_course_presistence, expected): course_api = CourseApi(mock_course_presistence) expected_identity = expected.map_or(lambda section: section.identity, None) mock_course_presistence.get_section = MagicMock(return_value=expected) assert course_api.get_section(expected_identity) == expected mock_course_presistence.get_section.assert_called_once_with(
def validate_float(x) -> Option[float]: try: f = float(x) except (TypeError, ValueError): return NONE return Some(f)
def test_duplicate(self, course_persistence): section = fake_section() course_persistence.get_section = MagicMock(return_value=Some(section)) assert (course_persistence.create_section(section).unwrap_err() == f"Section {section} already exists")
def test_duplicate(self, student_persistence): student = fake_student() student_persistence.get_student = MagicMock(return_value=Some(student)) assert (student_persistence.create_student( student, "aaaa").unwrap_err() == f"Student {student} already exists")
def test_duplicate(self, course_persistence): course = fake_course() course_persistence.get_course = MagicMock(return_value=Some(course)) assert (course_persistence.create_course(course).unwrap_err() == f"Course {course} already exists")