def test_get_format(self): """Test get format.""" course1 = factory.make_course('Portfolio2016', 'PAV', author=self.rein) course2 = factory.make_course('Portfolio2017', 'PAV', author=self.rein) course3 = factory.make_course('Portfolio2018', 'PAV') template = factory.make_entry_template('template') format = factory.make_format([template]) assignment = factory.make_assignment( 'Colloq', 'description1', format=format, courses=[course1, course2, course3]) login = test.logging_in(self, self.rein_user, self.rein_pass) response = test.api_get_call(self, '/formats/' + str(assignment.pk) + '/', login) self.assertEquals(response.json()['format']['templates'][0]['name'], 'template') # 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, '/formats/' + str(assignment.pk) + '/', login, status=403) test.api_get_call(self, '/formats/' + str(self.not_found_pk) + '/', login, status=404) test.test_unauthorized_api_get_call( self, '/formats/' + str(assignment.pk) + '/')
def set_up_courses(name, n, author=None, lti_id=False): """Set up some courses. Arguments: name -- the base for the incremental names for the courses n -- number of courses to be made author -- the user who made the course and it automatically will be teacher lti_id -- a boolean to determine if to give lti ids Returns a list of courses. """ courses = [] if lti_id: for i in range(n): courses.append( factory.make_course(name + str(i), name[0] + str(i), author=author, lti_id=str(i))) else: for i in range(n): courses.append( factory.make_course(name + str(i), name[0] + str(i), author=author)) return courses
def setUp(self): self.user = factory.make_user('Username', DEFAULT_PASSWORD, email='*****@*****.**', full_name='Test User') self.course1 = factory.make_course('Course', 'crs', startdate=datetime.date.today()) self.course2 = factory.make_course('Course2', 'crs2', startdate=datetime.date.today()) self.course_independent = factory.make_course('Independent Course', 'crs3', startdate=datetime.date.today()) self.assignment = factory.make_assignment('Assignment', 'Assignment linked to multiple courses.', courses=[self.course1, self.course2]) self.assignment_independent = factory.make_assignment('Assignment2', 'Assignment linked to separate course.', courses=[self.course_independent])
def test_get_lti_params_from_jwt_assignment_student(self): """Hopefully returns the lti assignment data.""" factory.make_course('TestCourse', 'aaaa', lti_id='asdf') login = test.logging_in(self, self.username, self.password) self.request["user_id"] = "awefd" self.request["roles"] = settings.ROLES["Student"] jwt_params = jwt.encode(self.request, settings.SECRET_KEY, algorithm='HS256').decode('utf-8') response = test.api_get_call( self, '/get_lti_params_from_jwt/{0}/'.format(jwt_params), login=login, status=404) self.assertIn('assignment', response.content.decode('utf-8'))
def test_get_names(self): """Test get names 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], is_published=True) student_user, student_pass, student = test.set_up_user_and_auth( 'student', 'pass', '*****@*****.**', 'first', 'last') test.set_up_participation(student, course, 'Student') journal = test.set_up_journal(assignment, template, student, 4) login = test.logging_in(self, student_user, student_pass) url = '/names/{}/{}/{}/'.format(course.pk, assignment.pk, journal.pk) result = test.api_get_call(self, url, login).json() self.assertEquals(result['names']['course'], 'Portfolio') self.assertEquals(result['names']['journal'], 'first last') self.assertEquals(result['names']['assignment'], 'Colloq') # 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, url, login, status=403)
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_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_format(self): """Test update format 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]) login = test.logging_in(self, self.rein_user, self.rein_pass) update_dict = { 'assignment_details': { 'name': 'Colloq', 'description': 'description1', 'is_published': True }, 'templates': [ serialize.TemplateSerializer(template).data for template in format.available_templates.all() ], 'removed_presets': [], 'removed_templates': [], 'presets': [], 'unused_templates': [] } test.api_patch_call(self, '/formats/' + str(assignment.pk) + '/', update_dict, login)
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): """Create a new course. Arguments: request -- request data name -- name of the course abbreviation -- abbreviation of the course startdate -- (optional) date when the course starts enddate -- (optional) date when the course ends lti_id -- (optional) lti_id to link the course to Returns: On failure: unauthorized -- when the user is not logged in forbidden -- when the user has no permission to create new courses On succes: success -- with the course data """ request.user.check_permission('can_add_course') name, abbr = utils.required_params(request.data, 'name', 'abbreviation') startdate, enddate, lti_id = utils.optional_params( request.data, 'startdate', 'enddate', 'lti_id') course = factory.make_course(name, abbr, startdate, enddate, request.user, lti_id) serializer = self.serializer_class(course, many=False) return response.created({'course': serializer.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 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_get_lti_params_from_jwt_assignment_teacher(self): """Hopefully returns the lti assignment data.""" factory.make_course('TestCourse', 'aaaa', lti_id='asdf') login = test.logging_in(self, self.username, self.password) self.request["user_id"] = "awefd" jwt_params = jwt.encode(self.request, settings.SECRET_KEY, algorithm='HS256').decode('utf-8') response = test.api_get_call( self, '/get_lti_params_from_jwt/{0}/'.format(jwt_params), login=login, status=200) self.assertIn( '"state": "{0}"'.format(lti_view.LTI_STATES.NEW_ASSIGN.value), response.content.decode('utf-8'))
def test_delete_assignment(self): """Test delete_assignment.""" login = test.logging_in(self, self.username, self.password) course1 = factory.make_course("Portfolio Academische Vaardigheden", "PAV") course2 = factory.make_course("BeeldBewerken", "BB") assign1 = factory.make_assignment("Colloq", "In de opdracht...1", self.user) assign2 = factory.make_assignment("Logboek", "In de opdracht...2", self.user) role = factory.make_role_default_no_perms("teacher", self.course, can_delete_assignment=True) factory.make_participation(user=self.user, course=self.course, role=role) role = factory.make_role_default_no_perms("teacher", course1, can_delete_assignment=True) factory.make_participation(user=self.user, course=course1, role=role) role = factory.make_role_default_no_perms("teacher", course2, can_delete_assignment=True) factory.make_participation(user=self.user, course=course2, role=role) assign1.courses.add(course1) assign1.courses.add(course2) assign2.courses.add(course1) # Stupid test to begin with, glad this is replaced soon test.api_del_call( self, '/assignments/{}/?course_id={}'.format(str(assign1.pk), self.course.pk), login) assignment = Assignment.objects.get(pk=assign1.pk) self.assertEquals(assignment.courses.count(), 2) test.api_del_call( self, '/assignments/{}/?course_id={}'.format(self.course.pk, self.course.pk), login) self.assertEquals(Assignment.objects.filter(pk=assign1.pk).count(), 1)
def test_check_if_need_VLE_publish_no_journals(self): """Hopefully doesnt crash.""" course = factory.make_course('TestCourse', 'aaaa', lti_id='qqsa') assign = factory.make_assignment("TestAss", "TestDescr", lti_id='aasas', courses=[course]) lti_grade.check_if_need_VLE_publish(assign)
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 setUp(self): """Setup""" self.username, self.password, self.user = test.set_up_user_and_auth( 'test', 'test123', '*****@*****.**') self.rein_user, self.rein_pass, self.rein = test.set_up_user_and_auth( "Rein", "123", '*****@*****.**') self.no_perm_user, self.no_perm_pass, self.no_permission_user = test.set_up_user_and_auth( "no_perm", "123", '*****@*****.**') self.course = factory.make_course("Beeldbewerken", "BB", enddate=timezone.now())
def test_assignment_journals(self): """Test the get assignment journals 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]) students = test.set_up_users('student', 2) for student in students: test.set_up_participation(student, course, 'Student') test.set_up_journal(assignment, template, student, 4) login = test.logging_in(self, self.rein_user, self.rein_pass) response = test.api_get_call(self, '/journals/', login, params={ 'course_id': course.pk, 'assignment_id': assignment.pk }) result = response.json() self.assertEquals(len(result['journals']), 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, '/journals/', login, status=403, params={ 'course_id': course.pk, 'assignment_id': assignment.pk }) test.api_get_call(self, '/journals/', login, status=404, params={ 'course_id': course.pk, 'assignment_id': self.not_found_pk }) test.api_get_call(self, '/journals/', login, status=400, params={}) test.test_unauthorized_api_get_call(self, '/journals/', params={ 'course_id': course.pk, 'assignment_id': self.not_found_pk })
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 setUp(self): """Set up the test file.""" self.username, self.password, self.user = test.set_up_user_and_auth( 'test123', 'test123', '*****@*****.**') self.rein_user, self.rein_pass, self.rein = test.set_up_user_and_auth( "Rein", "123", '*****@*****.**') self.no_perm_user, self.no_perm_pass, self.no_permission_user = test.set_up_user_and_auth( "no_perm", "123", '*****@*****.**') self.course = factory.make_course("Beeldbewerken", "BB") self.lars = factory.make_user("Lars", "123", "*****@*****.**") self.student1 = factory.make_user("Student1", "123", "Student1.com") self.student2 = factory.make_user("Student2", "123", "Student2.com") self.not_found_pk = 9999
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_get_user_teacher_courses(self): """Test get user teacher course function.""" factory.make_course('Portfolio2016', 'PAV', author=self.rein) factory.make_course('Portfolio2017', 'PAV', author=self.rein) factory.make_course('Portfolio2018', 'PAV') login = test.logging_in(self, self.rein_user, self.rein_pass) response = test.api_get_call(self, '/courses/', login) self.assertEquals(len(response.json()['courses']), 2) # permissions and authorization check for the api call. test.test_unauthorized_api_get_call(self, '/courses/')
def test_get_nodes(self): """Test the get nodes 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 = test.set_up_journal(assignment, template, student, 4) login = test.logging_in(self, student_user, student_pass) response = test.api_get_call(self, '/nodes/', login, params={'journal_id': journal.pk}) result = response.json() self.assertEquals(len(result['nodes']), 5) login = test.logging_in(self, self.rein_user, self.rein_pass) response = test.api_get_call(self, '/nodes/', login, params={'journal_id': journal.pk}) result = response.json() self.assertEquals(len(result['nodes']), 4) # 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, '/nodes/', login, status=403, params={'journal_id': journal.pk}) test.api_get_call(self, '/nodes/', login, status=404, params={'journal_id': self.not_found_pk}) test.test_unauthorized_api_get_call(self, '/nodes/', params={'journal_id': journal.pk})
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_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_get_assignment_data(self): """Test the get assignment data function.""" course = factory.make_course('Portfolio', 'PAV', author=self.rein) template = factory.make_entry_template('template') format1 = factory.make_format([template]) format2 = factory.make_format([template]) assignment1 = factory.make_assignment('Colloq', 'description1', format=format1, courses=[course], is_published=True) assignment2 = factory.make_assignment('Portfolio', 'description2', format=format2, courses=[course], is_published=True) test.set_up_participation(self.user, course, 'Student') login_user = test.logging_in(self, self.username, self.password) resp = test.api_get_call(self, '/assignments/' + str(assignment1.pk) + '/', login_user) self.assertEquals(resp.json()['assignment']['name'], 'Colloq') self.assertIn('journal', resp.json()['assignment']) login_rein = test.logging_in(self, self.rein_user, self.rein_pass) resp = test.api_get_call(self, '/assignments/' + str(assignment2.pk) + '/', login_rein) self.assertEquals(resp.json()['assignment']['name'], 'Portfolio') # 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/{}/'.format(assignment1.pk), login, status=403) test.api_get_call(self, '/assignments/{}/'.format(assignment2.pk), login, status=403) test.test_unauthorized_api_get_call( self, '/assignments/{}/'.format(assignment1.pk))
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_update_course(self): """Test update_course""" login = test.logging_in(self, self.username, self.password) course = factory.make_course("Portfolio Academische Vaardigheden", "PAV", author=self.user) test.api_patch_call( self, '/courses/' + str(course.pk) + '/', { 'name': 'Beeldbewerken', 'abbreviation': 'BB', 'startdate': course.startdate, 'enddate': course.enddate }, login) course = Course.objects.get(pk=course.pk) self.assertEquals(course.name, 'Beeldbewerken') self.assertEquals(course.abbreviation, 'BB')
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 test_get_lti_params_from_jwt_journal_teacher(self): """Hopefully returns the LTI assignment and course.""" course = factory.make_course('TestCourse', 'aaaa', lti_id='asdf') factory.make_assignment("TestAss", "TestDescr", lti_id='bughh', courses=[course]) login = test.logging_in(self, self.username, self.password) self.request["user_id"] = "awefd" jwt_params = jwt.encode(self.request, settings.SECRET_KEY, algorithm='HS256').decode('utf-8') response = test.api_get_call( self, '/get_lti_params_from_jwt/{0}/'.format(jwt_params), login=login, status=200) self.assertIn( '"state": "{0}"'.format(lti_view.LTI_STATES.FINISH_T.value), response.content.decode('utf-8'))