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