479 lines
16 KiB
Python
479 lines
16 KiB
Python
from django.test import TestCase
|
|
|
|
from vbv_lernwelt.assignment.models import (
|
|
Assignment,
|
|
AssignmentCompletion,
|
|
AssignmentCompletionStatus,
|
|
)
|
|
from vbv_lernwelt.core.constants import (
|
|
TEST_COURSE_SESSION_BERN_ID,
|
|
TEST_COURSE_SESSION_ZURICH_ID,
|
|
TEST_STUDENT1_USER_ID,
|
|
TEST_SUPERVISOR1_USER_ID,
|
|
)
|
|
from vbv_lernwelt.core.create_default_users import create_default_users
|
|
from vbv_lernwelt.core.models import User
|
|
from vbv_lernwelt.course.creators.test_course import create_test_course
|
|
from vbv_lernwelt.course.creators.test_utils import (
|
|
add_course_session_group_supervisor,
|
|
add_course_session_user,
|
|
create_course,
|
|
create_course_session,
|
|
create_course_session_group,
|
|
create_user,
|
|
)
|
|
from vbv_lernwelt.course.models import Course, CourseSession, CourseSessionUser
|
|
from vbv_lernwelt.dashboard.views import (
|
|
_get_allowed_course_session_ids_for_user,
|
|
_get_mentee_count,
|
|
_get_mentor_open_tasks_count,
|
|
get_course_config,
|
|
get_course_sessions_with_roles_for_user,
|
|
)
|
|
from vbv_lernwelt.learning_mentor.models import LearningMentor
|
|
from vbv_lernwelt.learnpath.models import LearningUnit
|
|
from vbv_lernwelt.self_evaluation_feedback.models import SelfEvaluationFeedback
|
|
|
|
|
|
class GetCourseSessionsForUserTestCase(TestCase):
|
|
def setUp(self):
|
|
self.course, _ = create_course("Test Course")
|
|
self.course_session = create_course_session(
|
|
course=self.course, title="Test Session"
|
|
)
|
|
|
|
def test_participant_get_sessions(self):
|
|
# participant gets all his sessions marked with role "MEMBER"
|
|
participant = create_user("participant")
|
|
add_course_session_user(
|
|
self.course_session,
|
|
participant,
|
|
role=CourseSessionUser.Role.MEMBER,
|
|
)
|
|
|
|
# WHEN
|
|
sessions = get_course_sessions_with_roles_for_user(participant)
|
|
|
|
# THEN
|
|
self.assertEqual(len(sessions), 1)
|
|
self.assertEqual(sessions[0].title, "Test Session")
|
|
self.assertSetEqual(sessions[0].roles, {"MEMBER"})
|
|
|
|
def test_trainer_get_sessions(self):
|
|
# GIVEN
|
|
# trainer gets all his sessions marked with role "EXPERT"
|
|
trainer = create_user("trainer")
|
|
add_course_session_user(
|
|
self.course_session,
|
|
trainer,
|
|
role=CourseSessionUser.Role.EXPERT,
|
|
)
|
|
|
|
# WHEN
|
|
sessions = get_course_sessions_with_roles_for_user(trainer)
|
|
|
|
# THEN
|
|
self.assertEqual(len(sessions), 1)
|
|
self.assertEqual(sessions[0].title, "Test Session")
|
|
self.assertSetEqual(sessions[0].roles, {"EXPERT"})
|
|
|
|
def test_supervisor_get_sessions(self):
|
|
supervisor = create_user("supervisor")
|
|
group = create_course_session_group(course_session=self.course_session)
|
|
add_course_session_group_supervisor(group=group, user=supervisor)
|
|
|
|
sessions = get_course_sessions_with_roles_for_user(supervisor)
|
|
|
|
# THEN
|
|
self.assertEqual(len(sessions), 1)
|
|
self.assertEqual(sessions[0].title, "Test Session")
|
|
self.assertEqual(sessions[0].roles, {"SUPERVISOR"})
|
|
|
|
def test_learning_mentor_get_sessions(self):
|
|
mentor = create_user("mentor")
|
|
LearningMentor.objects.create(mentor=mentor, course_session=self.course_session)
|
|
|
|
participant = create_user("participant")
|
|
add_course_session_user(
|
|
self.course_session,
|
|
participant,
|
|
role=CourseSessionUser.Role.MEMBER,
|
|
)
|
|
|
|
sessions = get_course_sessions_with_roles_for_user(mentor)
|
|
|
|
# THEN
|
|
self.assertEqual(len(sessions), 1)
|
|
self.assertEqual(sessions[0].title, "Test Session")
|
|
self.assertEqual(sessions[0].roles, {"LEARNING_MENTOR"})
|
|
|
|
|
|
class GetDashboardConfig(TestCase):
|
|
def setUp(self):
|
|
self.course, _ = create_course("Test Course")
|
|
self.course_session = create_course_session(
|
|
course=self.course, title="Test Session"
|
|
)
|
|
|
|
def _test_config(self, user, role, is_uk, is_vv, is_mentor, has_preview, widgets):
|
|
# WHEN
|
|
sessions = get_course_sessions_with_roles_for_user(user)
|
|
course_configs = get_course_config(sessions)
|
|
|
|
# THEN
|
|
self.assertEqual(len(course_configs), 1)
|
|
self.assertEqual(course_configs[0].course_title, self.course.title)
|
|
self.assertEqual(course_configs[0].is_uk, is_uk)
|
|
self.assertEqual(course_configs[0].is_vv, is_vv)
|
|
self.assertEqual(course_configs[0].is_mentor, is_mentor)
|
|
self.assertEqual(course_configs[0].has_preview, has_preview)
|
|
self.assertEqual(
|
|
course_configs[0].session_to_continue_id, str(self.course_session.id)
|
|
)
|
|
self.assertEqual(course_configs[0].role_key, role)
|
|
self.assertEqual(course_configs[0].widgets, widgets)
|
|
|
|
def test_participant_uk_get_config(self):
|
|
participant = create_user("participant")
|
|
add_course_session_user(
|
|
self.course_session,
|
|
participant,
|
|
role=CourseSessionUser.Role.MEMBER,
|
|
)
|
|
self.course.configuration.is_uk = True
|
|
self.course.configuration.save()
|
|
|
|
self._test_config(
|
|
user=participant,
|
|
role="Member",
|
|
is_uk=True,
|
|
is_vv=False,
|
|
is_mentor=False,
|
|
has_preview=False,
|
|
widgets=[
|
|
"ProgressWidget",
|
|
"CompetenceWidget",
|
|
"CompetenceCertificateWidget",
|
|
],
|
|
)
|
|
|
|
def test_participant_vv_get_config(self):
|
|
participant = create_user("participant")
|
|
add_course_session_user(
|
|
self.course_session,
|
|
participant,
|
|
role=CourseSessionUser.Role.MEMBER,
|
|
)
|
|
self.course.configuration.is_vv = True
|
|
self.course.configuration.save()
|
|
|
|
self._test_config(
|
|
user=participant,
|
|
role="Member",
|
|
is_uk=False,
|
|
is_vv=True,
|
|
is_mentor=False,
|
|
has_preview=False,
|
|
widgets=["ProgressWidget", "CompetenceWidget"],
|
|
)
|
|
|
|
def test_mentor_uk_get_config(self):
|
|
# GIVEN
|
|
mentor = create_user("mentor")
|
|
LearningMentor.objects.create(mentor=mentor, course_session=self.course_session)
|
|
|
|
self.course.configuration.is_uk = True
|
|
self.course.configuration.save()
|
|
|
|
self._test_config(
|
|
user=mentor,
|
|
role="MentorUK",
|
|
is_uk=True,
|
|
is_vv=False,
|
|
is_mentor=True,
|
|
has_preview=True,
|
|
widgets=["MentorPersonWidget", "MentorCompetenceWidget"],
|
|
)
|
|
|
|
def test_mentor_vv_get_config(self):
|
|
# GIVEN
|
|
mentor = create_user("mentor")
|
|
LearningMentor.objects.create(mentor=mentor, course_session=self.course_session)
|
|
|
|
self.course.configuration.is_vv = True
|
|
self.course.configuration.save()
|
|
|
|
self._test_config(
|
|
user=mentor,
|
|
role="MentorVV",
|
|
is_uk=False,
|
|
is_vv=True,
|
|
is_mentor=True,
|
|
has_preview=True,
|
|
widgets=["MentorPersonWidget", "MentorTasksWidget"],
|
|
)
|
|
|
|
def test_participant_as_mentor_vv_get_config(self):
|
|
# GIVEN
|
|
mentor = create_user("mentor")
|
|
add_course_session_user(
|
|
self.course_session,
|
|
mentor,
|
|
role=CourseSessionUser.Role.MEMBER,
|
|
)
|
|
LearningMentor.objects.create(mentor=mentor, course_session=self.course_session)
|
|
|
|
self.course.configuration.is_vv = True
|
|
self.course.configuration.save()
|
|
|
|
self._test_config(
|
|
user=mentor,
|
|
role="Member",
|
|
is_uk=False,
|
|
is_vv=True,
|
|
is_mentor=True,
|
|
has_preview=False,
|
|
widgets=[
|
|
"ProgressWidget",
|
|
"CompetenceWidget",
|
|
"MentorPersonWidget",
|
|
"MentorTasksWidget",
|
|
],
|
|
)
|
|
|
|
# test supervisor
|
|
# test expert
|
|
|
|
|
|
class GetMenteeCountTestCase(TestCase):
|
|
def setUp(self):
|
|
self.course, _ = create_course("Test Course")
|
|
self.course_session = create_course_session(
|
|
course=self.course, title="Test Session"
|
|
)
|
|
|
|
def test_get_mentee_count(self):
|
|
# GIVEN
|
|
participants_with_mentor = [create_user(f"participant{i}") for i in range(2)]
|
|
participant = create_user("participant")
|
|
mentor = create_user("mentor")
|
|
lm = LearningMentor.objects.create(
|
|
mentor=mentor, course_session=self.course_session
|
|
)
|
|
|
|
# WHEN
|
|
for p in participants_with_mentor:
|
|
csu = add_course_session_user(
|
|
self.course_session,
|
|
p,
|
|
role=CourseSessionUser.Role.MEMBER,
|
|
)
|
|
lm.participants.add(csu)
|
|
|
|
add_course_session_user(
|
|
self.course_session,
|
|
participant,
|
|
role=CourseSessionUser.Role.MEMBER,
|
|
)
|
|
|
|
# THEN
|
|
count = _get_mentee_count(str(self.course.id), mentor)
|
|
self.assertEqual(count, 2)
|
|
|
|
|
|
class BaseMentorAssignmentTestCase(TestCase):
|
|
def setUp(self):
|
|
create_default_users()
|
|
create_test_course(include_vv=False, with_sessions=True)
|
|
self.course = Course.objects.first()
|
|
self.course_session = CourseSession.objects.first()
|
|
self.lu = LearningUnit.objects.first()
|
|
self.assignment = Assignment.objects.first()
|
|
|
|
|
|
class GetMentorOpenTasksTestCase(BaseMentorAssignmentTestCase):
|
|
def setUp(self):
|
|
super().setUp()
|
|
self.course.configuration.is_vv = True
|
|
self.course.configuration.save()
|
|
|
|
self.mentor = create_user("mentor")
|
|
self.lm = LearningMentor.objects.create(
|
|
mentor=self.mentor, course_session=self.course_session
|
|
)
|
|
self.participants = [create_user(f"participant{i}") for i in range(2)]
|
|
|
|
def create_and_test_count(
|
|
self, assignment_user, evaluation_user, mentor, completion_status, count
|
|
):
|
|
AssignmentCompletion.objects.create(
|
|
course_session=self.course_session,
|
|
assignment_user=assignment_user,
|
|
assignment=self.assignment,
|
|
completion_status=completion_status,
|
|
evaluation_user=evaluation_user,
|
|
)
|
|
self.assertEqual(
|
|
_get_mentor_open_tasks_count(str(self.course.id), mentor), count
|
|
)
|
|
|
|
def test_get_uk_count(self):
|
|
self.course.configuration.is_uk = True
|
|
self.course.configuration.save()
|
|
count = _get_mentor_open_tasks_count(str(self.course.id), self.mentor)
|
|
self.assertEqual(count, 0)
|
|
|
|
def test_get_vv_count_when_assignment_evaluated(self):
|
|
# GIVEN
|
|
csu = add_course_session_user(
|
|
self.course_session,
|
|
self.participants[0],
|
|
role=CourseSessionUser.Role.MEMBER,
|
|
)
|
|
self.lm.participants.add(csu)
|
|
|
|
add_course_session_user(
|
|
self.course_session,
|
|
self.participants[1],
|
|
role=CourseSessionUser.Role.MEMBER,
|
|
)
|
|
|
|
AssignmentCompletion.objects.create(
|
|
course_session=self.course_session,
|
|
assignment_user=self.participants[0],
|
|
evaluation_user=self.participants[0],
|
|
assignment=self.assignment,
|
|
completion_status=AssignmentCompletionStatus.SUBMITTED.value,
|
|
)
|
|
|
|
self.create_and_test_count(
|
|
assignment_user=self.participants[0],
|
|
mentor=self.mentor,
|
|
evaluation_user=self.mentor,
|
|
completion_status=AssignmentCompletionStatus.EVALUATION_SUBMITTED.value,
|
|
count=0,
|
|
)
|
|
|
|
def test_get_vv_count_when_assignment_submitted(self):
|
|
csu = add_course_session_user(
|
|
self.course_session,
|
|
self.participants[0],
|
|
role=CourseSessionUser.Role.MEMBER,
|
|
)
|
|
self.lm.participants.add(csu)
|
|
|
|
add_course_session_user(
|
|
self.course_session,
|
|
self.participants[1],
|
|
role=CourseSessionUser.Role.MEMBER,
|
|
)
|
|
|
|
self.create_and_test_count(
|
|
assignment_user=self.participants[0],
|
|
mentor=self.mentor,
|
|
evaluation_user=self.mentor,
|
|
completion_status=AssignmentCompletionStatus.SUBMITTED.value,
|
|
count=1,
|
|
)
|
|
|
|
def test_get_vv_count_with_feedback_not_submitted(self):
|
|
csu = add_course_session_user(
|
|
self.course_session,
|
|
self.participants[0],
|
|
role=CourseSessionUser.Role.MEMBER,
|
|
)
|
|
self.lm.participants.add(csu)
|
|
|
|
SelfEvaluationFeedback.objects.create(
|
|
feedback_submitted=False,
|
|
feedback_requester_user=self.participants[0],
|
|
feedback_provider_user=self.mentor,
|
|
learning_unit=self.lu,
|
|
)
|
|
self.create_and_test_count(
|
|
assignment_user=self.participants[0],
|
|
mentor=self.mentor,
|
|
evaluation_user=self.mentor,
|
|
completion_status=AssignmentCompletionStatus.SUBMITTED.value,
|
|
count=2,
|
|
)
|
|
|
|
def test_get_vv_count_with_feedback_submitted(self):
|
|
csu = add_course_session_user(
|
|
self.course_session,
|
|
self.participants[0],
|
|
role=CourseSessionUser.Role.MEMBER,
|
|
)
|
|
self.lm.participants.add(csu)
|
|
|
|
SelfEvaluationFeedback.objects.create(
|
|
feedback_submitted=True,
|
|
feedback_requester_user=self.participants[0],
|
|
feedback_provider_user=self.mentor,
|
|
learning_unit=self.lu,
|
|
)
|
|
self.create_and_test_count(
|
|
assignment_user=self.participants[0],
|
|
mentor=self.mentor,
|
|
evaluation_user=self.mentor,
|
|
completion_status=AssignmentCompletionStatus.SUBMITTED.value,
|
|
count=1,
|
|
)
|
|
|
|
def test_get_vv_count_without_lm(self):
|
|
add_course_session_user(
|
|
self.course_session,
|
|
self.participants[0],
|
|
role=CourseSessionUser.Role.MEMBER,
|
|
)
|
|
|
|
SelfEvaluationFeedback.objects.create(
|
|
feedback_submitted=False,
|
|
feedback_requester_user=self.participants[0],
|
|
feedback_provider_user=self.mentor,
|
|
learning_unit=self.lu,
|
|
)
|
|
self.create_and_test_count(
|
|
assignment_user=self.participants[0],
|
|
mentor=self.mentor,
|
|
evaluation_user=self.mentor,
|
|
completion_status=AssignmentCompletionStatus.SUBMITTED.value,
|
|
count=0,
|
|
)
|
|
|
|
|
|
class ExportXlsTestCase(TestCase):
|
|
def setUp(self):
|
|
create_default_users()
|
|
create_test_course(include_vv=False, with_sessions=True)
|
|
|
|
def test_can_export_cs_dats(self):
|
|
# supervisor sees all cs in region
|
|
supervisor = User.objects.get(id=TEST_SUPERVISOR1_USER_ID)
|
|
requested_cs_ids = [TEST_COURSE_SESSION_ZURICH_ID, TEST_COURSE_SESSION_BERN_ID]
|
|
|
|
allowed_cs_id = _get_allowed_course_session_ids_for_user(
|
|
supervisor, requested_cs_ids
|
|
)
|
|
self.assertCountEqual(requested_cs_ids, allowed_cs_id)
|
|
|
|
def test_student_cannot_export_data(self):
|
|
# student cannot export any data
|
|
student = User.objects.get(id=TEST_STUDENT1_USER_ID)
|
|
requested_cs_ids = [TEST_COURSE_SESSION_ZURICH_ID]
|
|
|
|
allowed_cs_id = _get_allowed_course_session_ids_for_user(
|
|
student, requested_cs_ids
|
|
)
|
|
self.assertCountEqual([], allowed_cs_id)
|
|
|
|
def test_trainer_cannot_export_other_cs(self):
|
|
# trainer can only export cs where she is assigned
|
|
student = User.objects.get(email="test-trainer2@example.com")
|
|
requested_cs_ids = [TEST_COURSE_SESSION_BERN_ID, TEST_COURSE_SESSION_ZURICH_ID]
|
|
|
|
allowed_cs_id = _get_allowed_course_session_ids_for_user(
|
|
student, requested_cs_ids
|
|
)
|
|
self.assertCountEqual([TEST_COURSE_SESSION_ZURICH_ID], allowed_cs_id)
|