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)