def test_dao_create_mentorship_relation_with_mentor_already_in_relation(self): self.mentorship_relation = MentorshipRelationModel( action_user_id=self.admin_user.id, mentor_user=self.admin_user, mentee_user=self.second_user, creation_date=self.now_datetime.timestamp(), end_date=self.end_date_example.timestamp(), state=MentorshipRelationState.ACCEPTED, notes=self.notes_example, tasks_list=TasksListModel(), ) db.session.add(self.mentorship_relation) db.session.commit() dao = MentorshipRelationDAO() data = dict( mentor_id=self.second_user.id, mentee_id=self.first_user.id, end_date=self.end_date_example.timestamp(), notes=self.notes_example, tasks_list=TasksListModel(), ) # Use DAO to create a mentorship relation result = dao.create_mentorship_relation(self.second_user.id, data) self.assertEqual((messages.MENTOR_ALREADY_IN_A_RELATION, 400), result) query_mentorship_relations = MentorshipRelationModel.query.all() self.assertTrue(1, len(query_mentorship_relations))
def test_dao_list_mentorship_relation_state_none(self): DAO = MentorshipRelationDAO() result = DAO.list_mentorship_relations(user_id=self.first_user.id, state=None) expected_response = [self.mentorship_relation], 200 self.assertEqual(expected_response, result)
def test_dao_sender_does_not_exist_mentorship_request(self): DAO = MentorshipRelationDAO() result = DAO.accept_request(123, self.mentorship_relation.id) self.assertEqual((messages.USER_DOES_NOT_EXIST, 404), result) self.assertEqual(MentorshipRelationState.PENDING, self.mentorship_relation.state)
def test_dao_list_mentorship_relation_state_invalid(self): DAO = MentorshipRelationDAO() result = DAO.list_mentorship_relations(user_id=self.first_user.id, state="anything") expected_response = [], 400 self.assertEqual(expected_response, result)
def test_dao_accept_non_existing_mentorship_request(self): DAO = MentorshipRelationDAO() result = DAO.accept_request(self.first_user.id, 123) self.assertEqual( (messages.MENTORSHIP_RELATION_REQUEST_DOES_NOT_EXIST, 404), result) self.assertEqual(MentorshipRelationState.PENDING, self.mentorship_relation.state)
def test_dao_requester_tries_to_accept_mentorship_request(self): DAO = MentorshipRelationDAO() result = DAO.accept_request(self.first_user.id, self.mentorship_relation.id) self.assertEqual((messages.CANT_ACCEPT_MENTOR_REQ_SENT_BY_USER, 400), result) self.assertEqual(MentorshipRelationState.PENDING, self.mentorship_relation.state)
def test_dao_requester_tries_to_reject_mentorship_request(self): DAO = MentorshipRelationDAO() result = DAO.reject_request(self.first_user.id, self.mentorship_relation.id) self.assertEqual((messages.USER_CANT_REJECT_REQUEST_SENT_BY_USER, 403), result) self.assertEqual(MentorshipRelationState.PENDING, self.mentorship_relation.state)
def test_dao_receiver_accepts_mentorship_request(self): DAO = MentorshipRelationDAO() result = DAO.accept_request(self.second_user.id, self.mentorship_relation.id) self.assertEqual( (messages.MENTORSHIP_RELATION_WAS_ACCEPTED_SUCCESSFULLY, 200), result) self.assertEqual(MentorshipRelationState.ACCEPTED, self.mentorship_relation.state)
def test_dao_list_mentorship_relation_all(self): DAO = MentorshipRelationDAO() self.mentorship_relation.state = MentorshipRelationState.PENDING db.session.add(self.mentorship_relation) db.session.commit() result = DAO.list_mentorship_relations(user_id=self.first_user.id) expected_response = [self.mentorship_relation], 200 self.assertEqual(expected_response, result) self.assertIsNotNone(result)
def test_dao_list_mentorship_relation_completed(self): DAO = MentorshipRelationDAO() self.mentorship_relation.state = MentorshipRelationState.COMPLETED db.session.add(self.mentorship_relation) db.session.commit() result = DAO.list_mentorship_relations( user_id=self.first_user.id, state=self.mentorship_relation.state.name) expected_response = [self.mentorship_relation], 200 self.assertEqual(expected_response, result)
def test_dao_sender_cancel_mentorship_request(self): self.mentorship_relation.state = MentorshipRelationState.ACCEPTED db.session.add(self.mentorship_relation) db.session.commit() DAO = MentorshipRelationDAO() result = DAO.cancel_relation(self.first_user.id, self.mentorship_relation.id) self.assertEqual( (messages.MENTORSHIP_RELATION_WAS_CANCELLED_SUCCESSFULLY, 200), result ) self.assertEqual( MentorshipRelationState.CANCELLED, self.mentorship_relation.state )
def test_dao_create_mentorship_relation_with_good_args_mentor_is_receiver(self): dao = MentorshipRelationDAO() data = dict( mentor_id=self.first_user.id, mentee_id=self.second_user.id, end_date=self.end_date_example.timestamp(), notes=self.notes_example, tasks_list=TasksListModel(), ) # Use DAO to create a mentorship relation result = dao.create_mentorship_relation(self.second_user.id, data) self.assertEqual(messages.MENTORSHIP_RELATION_WAS_SENT_SUCCESSFULLY, result[0]) query_mentorship_relation = MentorshipRelationModel.query.first() self.assertTrue(query_mentorship_relation is not None) self.assertEqual(1, query_mentorship_relation.id) # asserting relation extra fields self.assertEqual(self.second_user.id, query_mentorship_relation.action_user_id) self.assertEqual(self.notes_example, query_mentorship_relation.notes) # asserting dates # asserting dates self.assertIsNone(query_mentorship_relation.start_date) self.assertEqual( self.end_date_example.timestamp(), query_mentorship_relation.end_date ) # asserting mentor and mentees setup self.assertEqual(self.first_user.id, query_mentorship_relation.mentor_id) self.assertEqual(self.second_user.id, query_mentorship_relation.mentee_id) # assert mentors' mentor_relations and mentee_relations self.assertEqual(1, len(self.first_user.mentor_relations)) self.assertEqual(query_mentorship_relation, self.first_user.mentor_relations[0]) self.assertEqual([], self.first_user.mentee_relations) # assert mentees' mentor_relations and mentee_relations self.assertEqual(1, len(self.second_user.mentee_relations)) self.assertEqual( query_mentorship_relation, self.second_user.mentee_relations[0] ) self.assertEqual([], self.second_user.mentor_relations)
def test_dao_list_current_mentorship_relation(self): result = MentorshipRelationDAO.list_current_mentorship_relation( user_id=self.first_user.id) expected_response = self.future_accepted_mentorship_relation self.assertEqual(expected_response, result)
def test_dao_create_mentorship_relation_with_good_args_but_invalid_timestamp(self): dao = MentorshipRelationDAO() data = dict( mentor_id=self.first_user.id, mentee_id=self.second_user.id, end_date=1580338800000000, notes=self.notes_example, tasks_list=TasksListModel(), ) # Use DAO to create a mentorship relation result = dao.create_mentorship_relation(self.first_user.id, data) self.assertEqual(messages.INVALID_END_DATE, result[0]) self.assertEqual(400, result[1])
def test_dao_list_pending_mentorship_relation(self): result = MentorshipRelationDAO.list_pending_mentorship_relations( user_id=self.first_user.id) expected_response = [self.future_pending_mentorship_relation] self.assertEqual(expected_response, result[0]) self.assertEqual(200, result[1])
def test_dao_list_past_mentorship_relations(self): result = MentorshipRelationDAO.list_past_mentorship_relations( user_id=self.first_user.id) expected_response = [self.past_mentorship_relation] self.assertIsNotNone(result[0]) self.assertEqual(expected_response, result[0])
def test_dao_sender_does_not_exist(self): result = MentorshipRelationDAO.delete_request( 123, self.mentorship_relation.id) self.assertEqual((messages.USER_DOES_NOT_EXIST, 404), result) self.assertIsNotNone( MentorshipRelationModel.query.filter_by( id=self.mentorship_relation.id).first())
def test_dao_mentee_user_already_in_relationship(self): DAO = MentorshipRelationDAO() result = DAO.accept_request(self.second_user.id, self.mentorship_relation.id) self.assertEqual( (messages.MENTORSHIP_RELATION_WAS_ACCEPTED_SUCCESSFULLY, 200), result) self.assertEqual(MentorshipRelationState.ACCEPTED, self.mentorship_relation.state) result3 = DAO.accept_request(self.third_user.id, self.mentorship_relation3.id) self.assertEqual((messages.MENTEE_ALREADY_IN_A_RELATION, 400), result3) self.assertEqual(MentorshipRelationState.PENDING, self.mentorship_relation3.state)
def test_dao_delete_non_existing_mentorship_request(self): result = MentorshipRelationDAO.delete_request(self.first_user.id, 123) self.assertEqual( (messages.MENTORSHIP_RELATION_REQUEST_DOES_NOT_EXIST, 404), result) self.assertIsNotNone( MentorshipRelationModel.query.filter_by( id=self.mentorship_relation.id).first())
def test_dao_receiver_tries_to_delete_mentorship_request(self): result = MentorshipRelationDAO.delete_request( self.second_user.id, self.mentorship_relation.id) self.assertEqual((messages.CANT_DELETE_UNINVOLVED_REQUEST, 400), result) self.assertIsNotNone( MentorshipRelationModel.query.filter_by( id=self.mentorship_relation.id).first())
def test_dao_create_mentorship_relation_with_non_existent_mentee(self): dao = MentorshipRelationDAO() data = dict( mentor_id=self.first_user.id, mentee_id=1234, end_date=self.end_date_example.timestamp(), notes=self.notes_example, tasks_list=TasksListModel(), ) # Use DAO to create a mentorship relation result = dao.create_mentorship_relation(self.first_user.id, data) self.assertDictEqual(messages.MENTEE_DOES_NOT_EXIST, result[0]) query_mentorship_relation = MentorshipRelationModel.query.first() self.assertIsNone(query_mentorship_relation)
def test_dao_mentorship_delete_request_not_in_pending_state(self): relation_id = self.mentorship_relation.id self.mentorship_relation.state = MentorshipRelationState.ACCEPTED db.session.add(self.mentorship_relation) db.session.commit() result = MentorshipRelationDAO.delete_request( self.first_user.id, self.mentorship_relation.id) self.assertEqual((messages.NOT_PENDING_STATE_RELATION, 400), result) self.assertIsNotNone( MentorshipRelationModel.query.filter_by(id=relation_id).first()) self.mentorship_relation.state = MentorshipRelationState.COMPLETED db.session.add(self.mentorship_relation) db.session.commit() result = MentorshipRelationDAO.delete_request( self.first_user.id, self.mentorship_relation.id) self.assertEqual((messages.NOT_PENDING_STATE_RELATION, 400), result) self.assertIsNotNone( MentorshipRelationModel.query.filter_by(id=relation_id).first()) self.mentorship_relation.state = MentorshipRelationState.CANCELLED db.session.add(self.mentorship_relation) db.session.commit() result = MentorshipRelationDAO.delete_request( self.first_user.id, self.mentorship_relation.id) self.assertEqual((messages.NOT_PENDING_STATE_RELATION, 400), result) self.assertIsNotNone( MentorshipRelationModel.query.filter_by(id=relation_id).first()) self.mentorship_relation.state = MentorshipRelationState.REJECTED db.session.add(self.mentorship_relation) db.session.commit() result = MentorshipRelationDAO.delete_request( self.first_user.id, self.mentorship_relation.id) self.assertEqual((messages.NOT_PENDING_STATE_RELATION, 400), result) self.assertIsNotNone( MentorshipRelationModel.query.filter_by(id=relation_id).first())
def test_dao_mentorship_request_is_not_in_pending_state(self): DAO = MentorshipRelationDAO() self.mentorship_relation.state = MentorshipRelationState.ACCEPTED db.session.add(self.mentorship_relation) db.session.commit() result = DAO.accept_request(self.second_user.id, self.mentorship_relation.id) self.assertEqual((messages.NOT_PENDING_STATE_RELATION, 400), result) self.mentorship_relation.state = MentorshipRelationState.COMPLETED db.session.add(self.mentorship_relation) db.session.commit() result = DAO.accept_request(self.second_user.id, self.mentorship_relation.id) self.assertEqual((messages.NOT_PENDING_STATE_RELATION, 400), result) self.mentorship_relation.state = MentorshipRelationState.CANCELLED db.session.add(self.mentorship_relation) db.session.commit() result = DAO.accept_request(self.second_user.id, self.mentorship_relation.id) self.assertEqual((messages.NOT_PENDING_STATE_RELATION, 400), result) self.mentorship_relation.state = MentorshipRelationState.REJECTED db.session.add(self.mentorship_relation) db.session.commit() result = DAO.accept_request(self.second_user.id, self.mentorship_relation.id) self.assertEqual((messages.NOT_PENDING_STATE_RELATION, 400), result)
def test_dao_mentorship_cancel_relation_not_in_accepted_state(self): DAO = MentorshipRelationDAO() self.mentorship_relation.state = MentorshipRelationState.PENDING db.session.add(self.mentorship_relation) db.session.commit() result = DAO.cancel_relation(self.second_user.id, self.mentorship_relation.id) self.assertEqual((messages.UNACCEPTED_STATE_RELATION, 400), result) self.mentorship_relation.state = MentorshipRelationState.COMPLETED db.session.add(self.mentorship_relation) db.session.commit() result = DAO.cancel_relation(self.second_user.id, self.mentorship_relation.id) self.assertEqual((messages.UNACCEPTED_STATE_RELATION, 400), result) self.mentorship_relation.state = MentorshipRelationState.CANCELLED db.session.add(self.mentorship_relation) db.session.commit() result = DAO.cancel_relation(self.second_user.id, self.mentorship_relation.id) self.assertEqual((messages.UNACCEPTED_STATE_RELATION, 400), result) self.mentorship_relation.state = MentorshipRelationState.REJECTED db.session.add(self.mentorship_relation) db.session.commit() result = DAO.cancel_relation(self.second_user.id, self.mentorship_relation.id) self.assertEqual((messages.UNACCEPTED_STATE_RELATION, 400), result)
def test_dao_sender_delete_mentorship_request(self): relation_id = self.mentorship_relation.id self.assertIsNotNone( MentorshipRelationModel.query.filter_by(id=relation_id).first()) result = MentorshipRelationDAO.delete_request(self.first_user.id, relation_id) self.assertEqual( (messages.MENTORSHIP_RELATION_WAS_DELETED_SUCCESSFULLY, 200), result) self.assertIsNone( MentorshipRelationModel.query.filter_by(id=relation_id).first())
def list_users(user_id: int, search_query: str = "", page: int = DEFAULT_PAGE, per_page: int = DEFAULT_USERS_PER_PAGE, is_verified=None): """ Retrieves a list of verified users with the specified ID. Arguments: user_id: The ID of the user to be listed. search_query: The search query for name of the users to be found. is_verified: Status of the user's verification; None when provided as an argument. page: The page of users to be returned per_page: The number of users to return per page Returns: A list of users matching conditions and the HTTP response code. """ users_list = UserModel.query.filter( UserModel.id != user_id, not is_verified or UserModel.is_email_verified, func.lower(UserModel.name).contains( search_query.lower())).order_by(UserModel.id).paginate( page=page, per_page=per_page, error_out=False, max_per_page=UserDAO.MAX_USERS_PER_PAGE).items list_of_users = [user.json() for user in users_list] for user in list_of_users: relation = MentorshipRelationDAO.list_current_mentorship_relation( user["id"]) if isinstance(relation, MentorshipRelationModel): user["is_available"] = False else: # we don't need if statement for this case # is_available is true # when either need_mentoring or available_to_mentor is true user["is_available"] = (user["need_mentoring"] or user["available_to_mentor"]) return list_of_users, HTTPStatus.OK
def test_dao_list_non_existing_current_mentorship_relation(self): result = MentorshipRelationDAO.list_current_mentorship_relation( user_id=self.admin_user.id) expected_response = (messages.NOT_IN_MENTORED_RELATION_CURRENTLY, 200) self.assertEqual(expected_response, result)
def get_user_dashboard(user_id): """ returns user dashboard: relations received. sent as mentor or mentee for all states. Also returns all done, to be done tasks if in a relation Args: user_id: id of the user whose dashboard is to be returned """ user = UserModel.find_by_id(user_id) if not user: return None response = {} all_user_relations = user.mentee_relations + user.mentor_relations relations_in_response_form = [ DashboardRelationResponseModel(relation) for relation in all_user_relations ] mentor_sent_relations = [ relation for relation in relations_in_response_form if relation.action_user_id == user_id and relation.mentor_id == user_id ] mentor_received_relations = [ relation for relation in relations_in_response_form if relation.action_user_id != user_id and relation.mentor_id == user_id ] mentee_sent_relations = [ relation for relation in relations_in_response_form if relation.action_user_id == user_id and relation.mentee_id == user_id ] mentee_received_relations = [ relation for relation in relations_in_response_form if relation.action_user_id != user_id and relation.mentee_id == user_id ] as_mentee = { "sent": { "accepted": [], "rejected": [], "completed": [], "cancelled": [], "pending": [], }, "received": { "accepted": [], "rejected": [], "completed": [], "cancelled": [], "pending": [], }, } as_mentor = { "sent": { "accepted": [], "rejected": [], "completed": [], "cancelled": [], "pending": [], }, "received": { "accepted": [], "rejected": [], "completed": [], "cancelled": [], "pending": [], }, } as_mentee["received"]["accepted"] = [ relation.response for relation in mentee_received_relations if relation.state == MentorshipRelationState.ACCEPTED ] as_mentee["received"]["rejected"] = [ relation.response for relation in mentee_received_relations if relation.state == MentorshipRelationState.REJECTED ] as_mentee["received"]["completed"] = [ relation.response for relation in mentee_received_relations if relation.state == MentorshipRelationState.COMPLETED ] as_mentee["received"]["cancelled"] = [ relation.response for relation in mentee_received_relations if relation.state == MentorshipRelationState.CANCELLED ] as_mentee["received"]["pending"] = [ relation.response for relation in mentee_received_relations if relation.state == MentorshipRelationState.PENDING ] as_mentor["received"]["accepted"] = [ relation.response for relation in mentor_received_relations if relation.state == MentorshipRelationState.ACCEPTED ] as_mentor["received"]["rejected"] = [ relation.response for relation in mentor_received_relations if relation.state == MentorshipRelationState.REJECTED ] as_mentor["received"]["completed"] = [ relation.response for relation in mentor_received_relations if relation.state == MentorshipRelationState.COMPLETED ] as_mentor["received"]["cancelled"] = [ relation.response for relation in mentor_received_relations if relation.state == MentorshipRelationState.CANCELLED ] as_mentor["received"]["pending"] = [ relation.response for relation in mentor_received_relations if relation.state == MentorshipRelationState.PENDING ] as_mentee["sent"]["accepted"] = [ relation.response for relation in mentee_sent_relations if relation.state == MentorshipRelationState.ACCEPTED ] as_mentee["sent"]["rejected"] = [ relation.response for relation in mentee_sent_relations if relation.state == MentorshipRelationState.REJECTED ] as_mentee["sent"]["completed"] = [ relation.response for relation in mentee_sent_relations if relation.state == MentorshipRelationState.COMPLETED ] as_mentee["sent"]["cancelled"] = [ relation.response for relation in mentee_sent_relations if relation.state == MentorshipRelationState.CANCELLED ] as_mentee["sent"]["pending"] = [ relation.response for relation in mentee_sent_relations if relation.state == MentorshipRelationState.PENDING ] as_mentor["sent"]["accepted"] = [ relation.response for relation in mentor_sent_relations if relation.state == MentorshipRelationState.ACCEPTED ] as_mentor["sent"]["rejected"] = [ relation.response for relation in mentor_sent_relations if relation.state == MentorshipRelationState.REJECTED ] as_mentor["sent"]["completed"] = [ relation.response for relation in mentor_sent_relations if relation.state == MentorshipRelationState.COMPLETED ] as_mentor["sent"]["cancelled"] = [ relation.response for relation in mentor_sent_relations if relation.state == MentorshipRelationState.CANCELLED ] as_mentor["sent"]["pending"] = [ relation.response for relation in mentor_sent_relations if relation.state == MentorshipRelationState.PENDING ] response["as_mentor"] = as_mentor response["as_mentee"] = as_mentee current_relation = MentorshipRelationDAO.list_current_mentorship_relation( user_id=user_id) if current_relation != (messages.NOT_IN_MENTORED_RELATION_CURRENTLY, HTTPStatus.OK): response["tasks_todo"] = marshal( [ task for task in current_relation.tasks_list.tasks if not task["is_done"] ], list_tasks_response_body, ) response["tasks_done"] = marshal( [ task for task in current_relation.tasks_list.tasks if task["is_done"] ], list_tasks_response_body, ) return response
COMMENT_MAX_LENGTH, ) from app.utils.validation_utils import get_length_validation_error_message from app.database.models.mentorship_relation import MentorshipRelationModel from app.api.email_utils import send_email_mentorship_relation_accepted from app.api.email_utils import send_email_new_request mentorship_relation_ns = Namespace( "Mentorship Relation", description="Operations related to " "mentorship relations " "between users", ) add_models_to_namespace(mentorship_relation_ns) DAO = MentorshipRelationDAO() userDAO = UserDAO() @mentorship_relation_ns.route("mentorship_relation/send_request") class SendRequest(Resource): @classmethod @jwt_required @mentorship_relation_ns.doc("send_request") @mentorship_relation_ns.expect(auth_header_parser, send_mentorship_request_body) @mentorship_relation_ns.response( HTTPStatus.CREATED, "%s" % messages.MENTORSHIP_RELATION_WAS_SENT_SUCCESSFULLY) @mentorship_relation_ns.response( HTTPStatus.BAD_REQUEST,