def test_is_supervisor(self):
middle = factory.make_user('Username2', DEFAULT_PASSWORD, email='*****@*****.**', full_name='Test User')
student = factory.make_user('Username3', DEFAULT_PASSWORD, email='*****@*****.**', full_name='Test User')
role = factory.make_role_default_no_perms("TE", self.course1,
can_view_course_users=True, can_view_all_journals=True)
factory.make_participation(self.user, self.course1, role)
role = factory.make_role_default_no_perms("MD", self.course1, can_view_course_users=True)
factory.make_participation(middle, self.course1, role)
role = factory.make_role_default_no_perms("SD", self.course1)
factory.make_participation(student, self.course1, role)
factory.make_journal(self.assignment, student)
assert permissions.is_user_supervisor_of(self.user, student)
assert permissions.is_user_supervisor_of(self.user, middle)
assert permissions.is_user_supervisor_of(middle, self.user)
assert permissions.is_user_supervisor_of(middle, student)
assert not permissions.is_user_supervisor_of(student, self.user)
assert not permissions.is_user_supervisor_of(student, middle)
Participation.objects.get(course=self.course1, user=student).delete()
assert permissions.is_user_supervisor_of(self.user, student)
assert not permissions.is_user_supervisor_of(middle, student)
assert not permissions.is_user_supervisor_of(student, self.user)
assert not permissions.is_user_supervisor_of(student, middle)
def test_is_supervisor(self):
middle = factory.make_user('Username2', 'Password', email='*****@*****.**')
student = factory.make_user('Username3', 'Password', email='*****@*****.**')
role = factory.make_role_default_no_perms("TE", self.course1,
can_view_course_users=True, can_view_all_journals=True)
factory.make_participation(self.user, self.course1, role)
role = factory.make_role_default_no_perms("MD", self.course1, can_view_course_users=True)
factory.make_participation(middle, self.course1, role)
role = factory.make_role_default_no_perms("SD", self.course1)
factory.make_participation(student, self.course1, role)
factory.make_journal(self.assignment, student)
self.assertTrue(permissions.is_user_supervisor_of(self.user, student))
self.assertTrue(permissions.is_user_supervisor_of(self.user, middle))
self.assertTrue(permissions.is_user_supervisor_of(middle, self.user))
self.assertTrue(permissions.is_user_supervisor_of(middle, student))
self.assertFalse(permissions.is_user_supervisor_of(student, self.user))
self.assertFalse(permissions.is_user_supervisor_of(student, middle))
Participation.objects.get(course=self.course1, user=student).delete()
self.assertTrue(permissions.is_user_supervisor_of(self.user, student))
self.assertFalse(permissions.is_user_supervisor_of(middle, student))
self.assertFalse(permissions.is_user_supervisor_of(student, self.user))
self.assertFalse(permissions.is_user_supervisor_of(student, middle))
def select_create_journal(request, user, assignment):
"""
Select or create the requested journal.
"""
if assignment is None or user is None:
return None
journals = Journal.objects.filter(user=user, assignment=assignment)
if journals.exists():
journal = journals.first()
else:
journal = factory.make_journal(assignment, user)
# Update the grade_url and sourcedid if the active LMS link is followed.
if assignment.active_lti_id == request['custom_assignment_id']:
passback_changed = False
if 'lis_outcome_service_url' in request and journal.grade_url != request[
'lis_outcome_service_url']:
passback_changed = True
journal.grade_url = request['lis_outcome_service_url']
journal.save()
if 'lis_result_sourcedid' in request and journal.sourcedid != request[
'lis_result_sourcedid']:
passback_changed = True
journal.sourcedid = request['lis_result_sourcedid']
journal.save()
if passback_changed:
send_journal_grade_to_LMS.delay(journal.pk)
return journal
def gen_journals(self):
"""Generate journals."""
self.journals = []
for a in self.assignments:
for u in self.users:
journal = factory.make_journal(a, u)
self.journals.append(journal)
def test_get_comments(self):
"""Test update comment function."""
course = factory.make_course('Portfolio', 'PAV', author=self.rein)
template = factory.make_entry_template('template')
format = factory.make_format([template])
assignment = factory.make_assignment('Colloq',
'description1',
format=format,
courses=[course])
student_user, student_pass, student = test.set_up_user_and_auth(
'student', 'pass', '*****@*****.**')
test.set_up_participation(student, course, 'Student')
journal = factory.make_journal(assignment, student)
entry = factory.make_entry(template)
factory.make_node(journal, entry)
comment = factory.make_comment(entry, self.rein, 'Excellent!', True)
login = test.logging_in(self, self.rein_user, self.rein_pass)
update_dict = {'text': 'Bad!'}
test.api_patch_call(self, '/comments/' + str(comment.pk) + '/',
update_dict, login)
q_comment = Comment.objects.get(pk=comment.pk)
self.assertEquals(q_comment.text, 'Bad!')
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 select_create_journal(request, user, assignment):
"""
Select or create the requested journal.
"""
if assignment is not None and user is not None:
journals = Journal.objects.filter(user=user, assignment=assignment)
if journals.count() > 0:
journal = journals[0]
else:
journal = factory.make_journal(assignment, user)
within_assignment_timeframe = False
try:
begin = datetime.strptime(request['custom_assignment_unlock'], '%Y-%m-%d %X %z')
end = datetime.strptime(request['custom_assignment_due'], '%Y-%m-%d %X %z')
now = datetime.now(timezone.utc)
within_assignment_timeframe = begin < now < end
except (ValueError, KeyError):
pass
if (journal.grade_url is None or within_assignment_timeframe) and 'lis_outcome_service_url' in request:
journal.grade_url = request['lis_outcome_service_url']
journal.save()
if (journal.sourcedid is None or within_assignment_timeframe) and 'lis_result_sourcedid' in request:
journal.sourcedid = request['lis_result_sourcedid']
journal.save()
else:
journal = None
return journal
def setUp(self):
"""Setup."""
self.u1 = factory.make_user("Zi", "pass", "*****@*****.**")
self.jf1 = factory.make_format()
self.jf2 = factory.make_format()
self.a1 = factory.make_assignment('tcolloq', 'description', format=self.jf1)
self.et1 = factory.make_entry_template('temp1')
self.et2 = factory.make_entry_template('temp2')
self.f1 = factory.make_field(self.et1, "test0", "1")
self.f2 = factory.make_field(self.et1, "test2", "2")
self.f3 = factory.make_field(self.et2, "test1", "1")
self.j1 = factory.make_journal(self.a1, self.u1)
self.e1 = factory.make_entry(self.et1)
self.e2 = factory.make_entry(self.et2)
self.c1 = factory.make_content(self.e1, "testcontent1", self.f1)
self.c2 = factory.make_content(self.e1, "testcontent2", self.f2)
self.c3 = factory.make_content(self.e2, "testcontent3", self.f3)
self.jf1.available_templates.add()
self.jf2.available_templates.add()
self.usr = factory.make_user('teun', '1234', email='*****@*****.**', lti_id='a')
self.crs = factory.make_course('test course please ignore', 'XXXX', startdate=datetime.date.today())
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 create(self, request):
"""Create a new assignment.
Arguments:
request -- request data
name -- name of the assignment
description -- description of the assignment
course_id -- id of the course the assignment belongs to
points_possible -- the possible amount of points for the assignment
unlock_date -- (optional) date the assignment becomes available on
due_date -- (optional) date the assignment is due for
lock_date -- (optional) date the assignment becomes unavailable on
lti_id -- id labeled link to LTI instance
Returns:
On failure:
unauthorized -- when the user is not logged in
not_found -- could not find the course with the given id
key_error -- missing keys
forbidden -- the user is not allowed to create assignments in this course
On success:
succes -- with the assignment data
"""
name, description, course_id = utils.required_params(request.data, "name", "description", "course_id")
points_possible, unlock_date, due_date, lock_date, lti_id, is_published = \
utils.optional_params(request.data, "points_possible", "unlock_date", "due_date", "lock_date", "lti_id",
"is_published")
course = Course.objects.get(pk=course_id)
request.user.check_permission('can_add_assignment', course)
assignment = factory.make_assignment(name, description, courses=[course],
author=request.user, lti_id=lti_id,
points_possible=points_possible,
unlock_date=unlock_date, due_date=due_date,
lock_date=lock_date, is_published=is_published)
for user in course.users.all():
factory.make_journal(assignment, user)
serializer = AssignmentSerializer(assignment, context={'user': request.user, 'course': course})
return response.created({'assignment': serializer.data})
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_get_course_assignments(self):
"""Test the get course assignment function."""
course = factory.make_course('Portfolio',
'PAV',
author=self.rein,
enddate=timezone.now())
assigns = test.set_up_assignments('assign', 'desc', 2, course=course)
test.set_up_participation(self.user, course, 'Student')
factory.make_journal(assigns[0], self.user)
factory.make_journal(assigns[1], self.user)
login_user = test.logging_in(self, self.username, self.password)
response = test.api_get_call(self,
'/assignments/',
login_user,
params={'course_id': course.pk})
self.assertEquals(len(response.json()['assignments']), 2)
self.assertIn('journal', response.json()['assignments'][0])
login_rein = test.logging_in(self, self.rein_user, self.rein_pass)
response = test.api_get_call(self,
'/assignments/',
login_rein,
params={'course_id': course.pk})
self.assertEquals(len(response.json()['assignments']), 2)
# permissions and authorization check for the api call.
login = test.logging_in(self, self.no_perm_user, self.no_perm_pass)
test.api_get_call(self,
'/assignments/',
login,
status=403,
params={'course_id': course.pk})
test.api_get_call(self,
'/assignments/',
login,
status=404,
params={'course_id': self.not_found_pk})
test.test_unauthorized_api_get_call(
self, '/assignments/' + str(course.pk) + '/')
def setUp(self):
"""Setup."""
self.u_rick = factory.make_user("Rick", "pass", "*****@*****.**")
self.u_lars = factory.make_user("Lars", "pass", "*****@*****.**")
self.template = Template(name="some_template")
self.template.save()
f_colloq = factory.make_format()
self.deadlineentry = factory.make_entrydeadline_node(
f_colloq,
datetime.datetime.now() - datetime.timedelta(days=10),
self.template)
self.progressnode = factory.make_progress_node(
f_colloq,
datetime.datetime.now() + datetime.timedelta(days=10), 10)
f_log = factory.make_format()
f_colloq.available_templates.add(self.template)
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 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 set_up_journal(assignment, template, user, n):
"""Set up a journal for an user with n entries.
Arguments:
assignment -- the assignment of the journal
template -- the entry template for the entries
user -- the user of the journal
n -- number of entries
Returns a journal with entries attached.
"""
journal = factory.make_journal(assignment, user)
for entry in set_up_entries(template, n):
factory.make_node(journal, entry)
return journal
def test_deadline_format(self):
"""Test if the deadline is correctly formatted."""
deadline = datetime.date.today()
format = factory.make_format()
format.save()
preset = factory.make_entrydeadline_node(format, deadline,
self.template)
self.assertEquals(deadline, preset.deadline)
assignment = factory.make_assignment("Portfolio",
"Fixed deadlines",
author=self.u_rick,
format=format)
journal = factory.make_journal(assignment, self.u_rick)
self.assertTrue(journal.node_set.get(preset__deadline=deadline))
def test_foreignkeys(self):
"""Test the foreign keys in the database."""
user_test = factory.make_user('lers', 'lers123', '*****@*****.**', '123456')
course_test = factory.make_course('tname', 'XXXX', datetime.date.today())
factory.make_format()
template = factory.make_entry_template("some_template")
entr_test = factory.make_entry(template)
field = factory.make_field(template, "test1", "1")
factory.make_content(entr_test, "data", field)
course_test.author = user_test
ass_test = factory.make_assignment(name='tcolloq', description='description')
ass_test.courses.add(course_test)
journ_test = factory.make_journal(user=user_test, assignment=ass_test)
self.assertEquals(entr_test.template.pk, template.pk)
self.assertEquals(journ_test.user.pk, user_test.pk)
self.assertEquals(journ_test.assignment.pk, ass_test.pk)
self.assertEquals(course_test.author.pk, user_test.pk)
def test_get_comments(self):
"""Test get comments function."""
course = factory.make_course('Portfolio', 'PAV', author=self.rein)
template = factory.make_entry_template('template')
format = factory.make_format([template])
assignment = factory.make_assignment('Colloq',
'description1',
format=format,
courses=[course])
student_user, student_pass, student = test.set_up_user_and_auth(
'student', 'pass', '*****@*****.**')
test.set_up_participation(student, course, 'Student')
journal = factory.make_journal(assignment, student)
entry = factory.make_entry(template)
factory.make_node(journal, entry)
factory.make_comment(entry, self.rein, 'Excellent!', True)
login = test.logging_in(self, student_user, student_pass)
result = test.api_get_call(self,
'/comments/',
login,
params={
'entry_id': entry.pk
}).json()
self.assertEquals(result['comments'][0]['text'], 'Excellent!')
# permissions and authorization check for the api call.
login = test.logging_in(self, self.no_perm_user, self.no_perm_pass)
test.api_get_call(self,
'/comments/',
login,
status=403,
params={'entry_id': entry.pk})
test.api_get_call(self,
'/comments/',
login,
status=404,
params={'entry_id': self.not_found_pk})
test.test_unauthorized_api_get_call(self,
'/comments/',
params={'entry_id': entry.pk})
def setUp(self):
"""Setup."""
self.factory = RequestFactory()
self.request = {
"oauth_consumer_key": settings.LTI_KEY,
"oauth_signature_method": "HMAC-SHA1",
"oauth_version": "1.0",
"custom_assignment_due": "2018-11-10 23:59:00 +0100",
"custom_assignment_id": "bughh",
"custom_assignment_lock": "2018-12-15 23:59:59 +0100",
"custom_assignment_title": "TestAss",
"custom_assignment_unlock": "2018-08-16 00:00:00 +0200",
"custom_assignment_points": "10",
"custom_assignment_publish": "true",
"custom_course_id": "asdf",
"custom_course_name": "TestCourse",
"custom_course_start": "2018-06-15 14:41:00 +0200",
"context_label": "aaaa",
"lti_message_type": "basic-lti-launch-request",
"lti_version": "LTI-1p0",
'custom_username': '******',
"roles": "Instructor",
"custom_user_image":
"https://uvadlo-tes.instructure.com/images/thumbnails/11601/\
6ivT7povCYWoXPCVOSnfPqWADsLktcGXTXkAUYDv",
"user_id": "0000"
}
self.oauth_consumer = oauth2.Consumer(settings.LTI_KEY,
settings.LTI_SECRET)
self.username, self.password, self.user = test.set_up_user_and_auth(
'TestUser', 'Pass', '*****@*****.**')
self.user.lti_id = 'awefd'
self.user.verified_email = True
self.user.save()
self.created_assignment = factory.make_assignment(
"TestAss", "TestDescr")
self.created_journal = factory.make_journal(self.created_assignment,
self.user)
def test_journal_stats(self):
"""Test the journal stats functions in the serializer."""
template = factory.make_entry_template('template_test')
format = factory.make_format([template])
assign = factory.make_assignment("Colloq", "In de opdracht...1", self.teacher, format=format)
journal = factory.make_journal(assign, self.user)
entries = test.set_up_entries(template, 4)
for entry in entries:
factory.make_node(journal, entry)
journal = Journal.objects.get(user=self.user)
entries = utils.get_journal_entries(journal)
for i in range(len(entries)):
if i > 0:
entries[i].grade = 1
entries[i].published = True
entries[i].save()
self.assertEquals(utils.get_acquired_points(entries), 3)
self.assertEquals(utils.get_submitted_count(entries), 4)
self.assertEquals(utils.get_graded_count(entries), 3)
def partial_update(self, request, *args, **kwargs):
"""Update an existing assignment.
Arguments:
request -- request data
data -- the new data for the assignment
pk -- assignment ID
Returns:
On failure:
unauthorized -- when the user is not logged in
not found -- when the assignment does not exist
forbidden -- User not allowed to edit this assignment
unauthorized -- when the user is unauthorized to edit the assignment
bad_request -- when there is invalid data in the request
On success:
success -- with the new assignment data
"""
pk, = utils.required_typed_params(kwargs, (int, 'pk'))
assignment = Assignment.objects.get(pk=pk)
request.user.check_permission('can_edit_assignment', assignment)
response_data = {}
# Remove data that must not be changed by the serializer
req_data = request.data
if not (request.user.is_superuser
or request.user == assignment.author):
req_data.pop('author', None)
# Check if the assignment can be unpublished
is_published, = utils.optional_params(request.data, 'is_published')
if not assignment.can_unpublish() and is_published is False:
return response.bad_request(
'You cannot unpublish an assignment that already has submissions.'
)
active_lti_course, = utils.optional_typed_params(
request.data, (int, 'active_lti_course'))
if active_lti_course is not None:
course = Course.objects.get(pk=active_lti_course)
active_lti_id = assignment.get_course_lti_id(course)
if active_lti_id:
assignment.active_lti_id = active_lti_id
assignment.save()
# Rename lti id key for serializer
if 'lti_id' in req_data:
course_id, = utils.required_params(request.data, 'course_id')
course = Course.objects.get(pk=course_id)
request.user.check_permission('can_add_assignment', course)
if course in assignment.courses.all():
return response.bad_request(
'Assignment already used in course.')
course.set_assignment_lti_id_set(req_data['lti_id'])
course.save()
assignment.courses.add(course)
assignment.save()
for user in User.objects.filter(
participation__course=course).exclude(
journal__assignment=assignment):
factory.make_journal(assignment, user)
req_data['active_lti_id'] = req_data.pop('lti_id')
# Update the other data
serializer = AssignmentSerializer(assignment,
data=req_data,
context={'user': request.user},
partial=True)
if not serializer.is_valid():
return response.bad_request()
serializer.save()
response_data['assignment'] = serializer.data
return response.success(response_data)
