def test_create_entry(self): """"Test create entry.""" _, _, user2 = test.set_up_user_and_auth('testh', 'test123h', '*****@*****.**') course = factory.make_course('Portfolio', 'PAV', author=user2) template = factory.make_entry_template("some_template") format = factory.make_format([template]) assignment = factory.make_assignment("Assignment", "Your favorite assignment", format=format, courses=[course]) journal = factory.make_journal(assignment, self.user) field = factory.make_field(template, 'Some field', 0) login = test.logging_in(self, self.username, self.password) format.available_templates.add(template) role = factory.make_role_default_no_perms("student", course, can_have_journal=True) factory.make_participation(user=self.user, course=course, role=role) create_entry_dict = { 'journal_id': journal.id, 'template_id': template.id, 'content': [{ 'id': field.pk, 'data': "This is some data" }] } test.api_post_call(self, '/entries/', create_entry_dict, login, 201) self.assertTrue(Entry.objects.filter(node__journal=journal).exists()) self.assertEquals( Content.objects.get(entry=1).data, "This is some data")
def test_create_new_assignment(self): """test create new assignment.""" lti_id = '12AB' course = factory.make_course("BeeldBewerken", "BB", enddate=timezone.now()) role = factory.make_role_default_no_perms("teacher", course, can_add_assignment=True) factory.make_participation(user=self.user, course=course, role=role) login = test.logging_in(self, self.username, self.password) create_assign_dict = { 'name': 'SIFT', 'description': 'In this assign...', 'course_id': course.pk, 'lti_id': lti_id } test.api_post_call(self, '/assignments/', params=create_assign_dict, login=login, status=201) self.assertEquals( Lti_ids.objects.get(lti_id=lti_id).assignment.name, 'SIFT')
def setUp(self): self.admin = factory.Admin() self.student = factory.Student() self.journal = factory.Journal(user=self.student) self.TA = factory.Student() nfac.make_participation( user=self.TA, course=self.journal.assignment.courses.first(), role=self.journal.assignment.courses.first().role_set.get( name='TA')) self.teacher = self.journal.assignment.courses.first().author self.comment = factory.StudentComment( entry__node__journal=self.journal) self.TA_comment = nfac.make_comment(self.comment.entry, self.TA, 'TA comment', False) self.teacher_comment = nfac.make_comment(self.comment.entry, self.teacher, 'Teacher comment', False) set_entry_comment_counts(self) assert self.teacher.has_permission('can_grade', self.journal.assignment), \ 'Teacher requires can_grade permission in the relevant assignment' assert self.TA.has_permission('can_grade', self.journal.assignment), \ 'TA requires can_grade permission in the relevant assignment' assert not self.teacher_comment.published, 'Teacher comment should be unpublished.' assert not self.TA_comment.published, 'TA comment should be unpublished.' assert self.entry_comments == 3, 'Journal should have 3 comments total' assert self.entry_published_comments == 1, 'Journal should have 3 comments of which only one is published' assert self.entry_unpublished_comments == 2, 'Expected 2 unpublished comments'
def test_update_user_role_course(self): """Test user role update in a course.""" login = test.logging_in(self, self.rein_user, self.rein_pass) course = factory.make_course("Portfolio Academische Vaardigheden", "PAV", author=self.rein) ta_role = Role.objects.get(name='TA', course=course) student_role = factory.make_role_student(name='SD', course=course) self.user_role = factory.make_user("test123", "test", "*****@*****.**") factory.make_participation(self.user_role, course, ta_role) factory.make_participation(self.user, course, student_role) user_role = Participation.objects.get(user=self.user_role, course=course).role.name self.assertEquals(user_role, 'TA') test.api_patch_call(self, '/participations/' + str(course.pk) + '/', { 'user_id': self.user_role.pk, 'role': 'SD' }, login) user_role = Participation.objects.get(user=self.user_role, course=course.pk).role.name self.assertEquals(user_role, 'SD')
def test_update_course_roles(self): """Test update course roles""" teacher_user, teacher_pass, teacher = test.set_up_user_and_auth( 'Teacher', 'pass', '*****@*****.**') teacher_role = factory.make_role_teacher("TE", self.course) factory.make_role_ta('TA2', self.course) factory.make_participation(teacher, self.course, teacher_role) login = test.logging_in(self, teacher_user, teacher_pass) result = test.api_get_call(self, '/roles/', login, params={'course_id': self.course.pk}) roles = result.json()['roles'] for role in roles: if role['name'] == 'TA2': role['can_grade'] = 1 roles.append( serialize.RoleSerializer( factory.make_role_default_no_perms('test_role', self.course)).data) test.api_patch_call(self, '/roles/{}/'.format(self.course.pk), {'roles': roles}, login) role_test = Role.objects.get(name='TA2', course=self.course) self.assertTrue(role_test.can_grade) self.assertEquals( Role.objects.filter(name='test_role', course=self.course).count(), 1)
def test_is_assignment_participant(self): """Test if is_participant correctly represent whether the user is participating in an assignment or not.""" role = factory.make_role_default_no_perms("SD", self.course_independent) factory.make_participation(self.user, self.course_independent, role) assert self.user.is_participant(self.assignment_independent) assert not self.user.is_participant(self.assignment)
def test_check_permission(self): """Test whether check_permission throws VLEPermissionError when it should throw.""" role = factory.make_role_default_no_perms("SD", self.course1, can_delete_course=True, can_have_journal=True) factory.make_participation(self.user, self.course1, role) self.user.check_permission('can_delete_course', self.course1) self.assertRaises(VLEPermissionError, self.user.check_permission, 'can_view_course_users', self.course1) self.user.check_permission('can_have_journal', self.assignment) self.assertRaises(VLEPermissionError, self.user.check_permission, 'can_grade', self.assignment)
def test_no_permissions(self): """Ensure the user has no permissions when given no permissions.""" role = factory.make_role_default_no_perms('SD', self.course_independent) factory.make_participation(self.user, self.course_independent, role) assert not self.user.has_permission('can_edit_institute_details') assert not self.user.has_permission('can_add_course') assert not self.user.has_permission('can_delete_course', self.course_independent) assert not self.user.has_permission('can_have_journal', self.assignment_independent)
def test_permission(self): """Test whether the user has only the given permission.""" role = factory.make_role_default_no_perms("SD", self.course_independent, can_delete_assignment=True) factory.make_participation(self.user, self.course_independent, role) assert self.user.has_permission('can_delete_assignment', self.course_independent) assert not self.user.has_permission('can_delete_course_user_group', self.course_independent) self.assertRaises(VLEParticipationError, self.user.has_permission, 'can_delete_assignment', self.course1) self.assertRaises(VLEParticipationError, self.user.has_permission, 'can_delete_assignment', self.course2)
def test_assignment_permission(self): """Test whether the user has only the given assignment permission.""" role = factory.make_role_default_no_perms("SD", self.course_independent, can_have_journal=True) factory.make_participation(self.user, self.course_independent, role) assert self.user.has_permission('can_have_journal', self.assignment_independent) assert not self.user.has_permission('can_add_course') assert not self.user.has_permission('can_edit_assignment', self.assignment_independent) self.assertRaises(VLEParticipationError, self.user.has_permission, 'can_have_journal', self.assignment)
def test_multi_course_assignment_permission(self): """Test whether the assignment has the correct permissions when bound to multiple courses.""" role = factory.make_role_default_no_perms("SD", self.course1, can_have_journal=True) factory.make_participation(self.user, self.course1, role) role = factory.make_role_default_no_perms("SD", self.course2, can_have_journal=False) factory.make_participation(self.user, self.course2, role) assert self.user.has_permission('can_have_journal', self.assignment) assert not self.user.has_permission('can_edit_assignment', self.assignment)
def test_is_course_participant(self): """Test if is_participant correctly represents whether the user is participating in a course or not.""" role = factory.make_role_default_no_perms("SD", self.course_independent) factory.make_participation(self.user, self.course_independent, role) self.assertTrue(self.user.is_participant(self.course_independent)) self.assertFalse(self.user.is_participant(self.course1)) self.assertFalse(self.user.is_participant(self.course2))
def test_check_participation(self): """Tests whether check_participation throws VLEParticipationError when it should throw.""" role = factory.make_role_default_no_perms("SD", self.course1) factory.make_participation(self.user, self.course1, role) self.user.check_participation(self.course1) self.assertRaises(VLEParticipationError, self.user.check_participation, self.course_independent) self.assertRaises(VLEParticipationError, self.user.check_participation, self.course2) self.user.check_participation(self.assignment) self.assertRaises(VLEParticipationError, self.user.check_participation, self.assignment_independent)
def test_multi_course_assignment_negations(self): """Test whether the assignment has the correct permissions when bound to multiple courses, by negation.""" role = factory.make_role_default_no_perms("SD", self.course1, can_have_journal=True) factory.make_participation(self.user, self.course1, role) role = factory.make_role_default_no_perms("SD", self.course2, can_view_all_journals=True) factory.make_participation(self.user, self.course2, role) self.assertTrue(self.user.has_permission('can_view_all_journals', self.assignment)) self.assertFalse(self.user.has_permission('can_have_journal', self.assignment))
def _make_lti_participation(user, course, lti_role): """Make the user a participant in the course. This function also adds the role if this is a valid role registered in our system. """ for role in settings.ROLES: if role in lti_role: return factory.make_participation( user, course, Role.objects.get(name=role, course=course)) return factory.make_participation( user, course, Role.objects.get(name='Student', course=course))
def test_is_multi_participant(self): """Test if participating in one course does not implicitly participate the user in another course or assignment.""" role = factory.make_role_default_no_perms("SD", self.course1) factory.make_participation(self.user, self.course1, role) assert self.user.is_participant(self.course1) assert self.user.is_participant(self.assignment) assert not self.user.is_participant(self.course2) assert not self.user.is_participant(self.course_independent) assert not self.user.is_participant(self.assignment_independent)
def test_select_course_with_participation(self): """Hopefully select a course.""" course = factory.make_course('TestCourse', 'aaaa', lti_id='asdf') factory.make_participation( self.user, course, Role.objects.create(name='role', course=course)) selected_course = lti.check_course_lti( { 'custom_course_id': Lti_ids.objects.filter(course=course)[0].lti_id, }, user=self.user, role=settings.ROLES['Teacher']) self.assertEquals(selected_course, course)
def test_get_user_courses(self): """Test the get user courses function.""" for course in test.set_up_courses('course', 4): student_role = Role.objects.get(name='Student', course=course) factory.make_participation(self.user, course, student_role) login = test.logging_in(self, self.username, self.password) response = test.api_get_call(self, '/courses/', login) self.assertEquals(len(response.json()['courses']), 4) # permissions and authorization check for the api call. test.test_unauthorized_api_get_call(self, '/courses/')
def setUp(self): """Setup.""" self.course = factory.make_course('TestCourse', 'aaaa', lti_id='asdf') self.user = factory.make_user('TestUser', 'Pass', '*****@*****.**') factory.make_participation( self.user, self.course, Role.objects.get(name='Student', course=self.course)) self.assignment = factory.make_assignment("TestAss", "TestDescr", points_possible=100, courses=[self.course]) self.journal = factory.make_journal(self.assignment, self.user) self.journal.sourcedid = 'f6d552' self.journal.grade_url = 'http://127.0.0.1:8000/grade_passback'
def test_delete_course_role(self): """Test delete course roles""" teacher_user = '******' teacher_pass = '******' teacher = factory.make_user(teacher_user, teacher_pass, "*****@*****.**") teacher_role = factory.make_role_teacher("TE", self.course) factory.make_participation(teacher, self.course, teacher_role) factory.make_role_ta('TA2', self.course) login = test.logging_in(self, teacher_user, teacher_pass) test.api_del_call(self, '/roles/' + str(self.course.pk) + '/?name=TA2', login) self.assertEquals( Role.objects.filter( name='TA2', course=Course.objects.get(pk=self.course.pk)).count(), 0)
def create(self, request): """Add a user to a course. Arguments: request -- request data user_id -- user ID course_id -- course ID Returns: On failure: unauthorized -- when the user is not logged in not found -- when course or user is not found forbidden -- when the logged in user is not connected to the course bad request -- when the new user is already connected to the course not found -- when the role doesnt exist On success: success -- success message """ user_id, course_id = utils.required_typed_params( request.data, (int, 'user_id'), (int, 'course_id')) role_name = 'Student' user = User.objects.get(pk=user_id) course = Course.objects.get(pk=course_id) request.user.check_permission('can_add_course_users', course) if user.is_participant(course): return response.bad_request( 'User already participates in the course.') role = Role.objects.get(name=role_name, course=course) factory.make_participation(user, course, role) assignments = course.assignment_set.all() for assignment in assignments: if not Journal.objects.filter(assignment=assignment, user=user).exists(): factory.make_journal(assignment, user) serializer = UserSerializer(user, context={'course': course}) return response.created( {'participant': serializer.data}, description='Successfully added student to course.')
def test_delete_group(self): """test create group.""" login = test.logging_in(self, self.username, self.password) course = factory.make_course("Portfolio Academische Vaardigheden", "PAV") role = factory.make_role_default_no_perms( "teacher", course, can_add_course_user_group=True, can_delete_course_user_group=True) factory.make_participation(user=self.user, course=course, role=role) factory.make_course_group('group1', course) factory.make_course_group('group2', course) test.api_del_call(self, '/groups/' + str(course.pk) + '/?group_name=group1', login)
def test_create_group(self): """test create group.""" login = test.logging_in(self, self.username, self.password) course = factory.make_course("Portfolio Academische Vaardigheden", "PAV") create_group_dict = {'name': 'TestGroup', 'course_id': course.pk} role = factory.make_role_default_no_perms( "teacher", course, can_add_course_user_group=True) factory.make_participation(user=self.user, course=course, role=role) test.api_post_call(self, '/groups/', params=create_group_dict, login=login, status=201) self.assertTrue( Group.objects.filter(name='TestGroup', course=course).exists())
def test_serialize(self): result = permissions.serialize_general_permissions(self.user) assert not result['can_edit_institute_details'] assert not result['can_add_course'] self.assertEqual(len(permissions.GENERAL_PERMISSIONS), len(result)) role = factory.make_role_default_no_perms("SD", self.course_independent, can_view_course_users=True, can_edit_assignment=True) factory.make_participation(self.user, self.course_independent, role) result = permissions.serialize_course_permissions(self.user, self.course_independent) assert result['can_view_course_users'] assert not result['can_edit_course_details'] self.assertEqual(len(permissions.COURSE_PERMISSIONS), len(result)) result = permissions.serialize_assignment_permissions(self.user, self.assignment_independent) assert result['can_edit_assignment'] assert not result['can_have_journal'] self.assertEqual(len(permissions.ASSIGNMENT_PERMISSIONS), len(result))
def test_delete_course(self): """Test delete_course""" login = test.logging_in(self, self.username, self.password) bb = factory.make_course("Beeldbewerken", "BB") factory.make_course("Portfolio Academische Vaardigheden", "PAV") role = factory.make_role_default_no_perms("teacher", bb, can_delete_course=True) factory.make_participation(user=self.user, course=bb, role=role) test.api_del_call(self, '/courses/' + str(bb.pk) + '/', login) self.assertEquals( Course.objects.filter(name="Beeldbewerken").count(), 1) self.assertEquals( Course.objects.filter( name="Portfolio Academische Vaardigheden").count(), 1)
def check_course_lti(request, user, role): """Check if a course with the lti_id exists. If it does, put the user in the group with the right group and role.""" course_id = request['custom_course_id'] lti_couple = Lti_ids.objects.filter(lti_id=course_id, for_model=Lti_ids.COURSE).first() if not lti_couple: return None course = lti_couple.course lti_id, = utils.optional_params(request, 'custom_section_id') # If the user is participatant, but not yet in a group, put the user in the Canvas related group. if user.is_participant(course): participation = Participation.objects.get(course=course, user=user) if not participation.group and lti_id: groups = Group.objects.filter(lti_id=lti_id, course=course) if groups.exists(): participation.group = groups[0] else: group = factory.make_course_group(lti_id, course, lti_id) participation.group = group participation.save() return course participation = None for r in settings.ROLES: if r in role: participation = factory.make_participation(user, course, Role.objects.get(name=r, course=course)) break if not participation: participation = factory.make_participation(user, course, Role.objects.get(name='Student', course=course)) groups = Group.objects.filter(lti_id=lti_id, course=course) if groups.exists(): participation.group = groups[0] else: group = factory.make_course_group(lti_id, course, lti_id) participation.group = group participation.save() return course
def test_update_assignment(self): """Test update assignment""" teacher_user, teacher_pass, teacher = test.set_up_user_and_auth( 'Teacher', 'pass', '*****@*****.**') teacher_role = factory.make_role_teacher("TE", self.course) factory.make_participation(teacher, self.course, teacher_role) assign = test.set_up_assignments('Assign', '', 1, self.course)[0] login = test.logging_in(self, teacher_user, teacher_pass) test.api_patch_call(self, '/assignments/' + str(assign.pk) + '/', { 'name': 'Assign2', 'description': 'summary', 'is_published': True }, login) assign = Assignment.objects.get(pk=assign.pk) self.assertEquals(assign.name, 'Assign2') self.assertEquals(assign.description, 'summary')
def gen_courses(self): """Generate courses.""" courses_examples = [ { "pk": 1697, "name": "Portfolio Academische Vaardigheden 1", "abbr": "PAV1", "students": [0, 1, 2, 3, 4], "teachers": [5], "start_date": faker.date("2018-09-01"), "end_date": faker.date("2019-09-01"), }, { "pk": 1698, "name": "Portfolio Academische Vaardigheden 2", "abbr": "PAV2", "students": [0, 1, 2, 3, 4], "teachers": [5], "start_date": faker.date("2018-09-01"), "end_date": faker.date("2019-09-01"), } ] self.courses = [] for c in courses_examples: author = self.users[c["teachers"][0]] course = Course(pk=c["pk"], name=c["name"], abbreviation=c["abbr"], startdate=c["start_date"], enddate=c["end_date"], author=author) course.save() factory.make_role_student('Student', course) factory.make_role_ta('TA', course) factory.make_role_teacher('Teacher', course) role_teacher = Role.objects.get(name='Teacher', course=course) role_student = Role.objects.get(name='Student', course=course) for sid in c["students"]: factory.make_participation(self.users[sid], course, role_student) for cid in c["teachers"]: factory.make_participation(self.users[cid], course, role_teacher) self.courses.append(course)
def setUp(self): """Setup.""" self.u_rick = factory.make_user("Rick", DEFAULT_PASSWORD, "*****@*****.**", full_name='Test User') self.u_lars = factory.make_user("Lars", DEFAULT_PASSWORD, "*****@*****.**", full_name='Test User') f_colloq = factory.make_default_format() self.deadlineentry = factory.make_entrydeadline_node( f_colloq, due_date=datetime.datetime.now() - datetime.timedelta(days=10), template=f_colloq.template_set.first()) self.progressnode = factory.make_progress_node( f_colloq, datetime.datetime.now() + datetime.timedelta(days=10), 10) f_log = factory.make_default_format() self.template = f_colloq.template_set.first() course = factory.make_course("Some Course", "c") student_role = Role.objects.get(name='Student', course=course) factory.make_participation(self.u_rick, course, student_role) a_colloq = factory.make_assignment("Colloq", "In de opdracht...1", author=self.u_rick, format=f_colloq, courses=[course]) a_log = factory.make_assignment("Logboek", "In de opdracht...2", author=self.u_rick, format=f_log, courses=[course]) self.j_rick_colloq = factory.make_journal(a_colloq, self.u_rick) self.j_lars_colloq = factory.make_journal(a_colloq, self.u_lars) self.j_rick_log = factory.make_journal(a_log, self.u_rick)
def test_update_course_with_student(self): """Test update_course_with_student""" login = test.logging_in(self, self.username, self.password) course = factory.make_course("Portfolio Academische Vaardigheden", "PAV") teacher_role = Role.objects.get(name='Teacher', course=course) factory.make_participation(self.user, course, teacher_role) student = factory.make_user("Rick", "pass", "*****@*****.**") test.api_post_call(self, '/participations/', { 'user_id': student.pk, 'course_id': course.pk }, login) course = Course.objects.get(pk=course.pk) self.assertEquals(len(course.users.all()), 2) self.assertTrue( User.objects.filter(participation__course=course, username='******').exists())