def test_pages(self): """ Test basic page rendering """ c = Client() c.login_user('dzhao') test_views(self, c, 'ra:', ['search', 'new', 'accounts_index', 'new_account', 'projects_index', 'new_project', 'semester_config', 'browse'], {}) test_views(self, c, 'ra:', ['found'], {}, qs='search=grad') ra = RAAppointment.objects.filter(unit__label='CMPT')[0] p = ra.person test_views(self, c, 'ra:', ['student_appointments', 'new_student'], {'userid': p.userid}) test_views(self, c, 'ra:', ['edit', 'reappoint', 'view',], {'ra_slug': ra.slug}) # No offer text yet, we should get a redirect when trying to edit the letter text: url = reverse('ra:edit_letter', kwargs={'ra_slug': ra.slug}) response = c.get(url) self.assertEqual(response.status_code, 302) # Let's add some offer text and try again. ra.offer_letter_text='Some test text here' ra.save() test_views(self, c, 'ra:', ['edit_letter'], {'ra_slug': ra.slug}) # Make sure we can add attachments test_views(self, c, 'ra:', ['new_attachment'], {'ra_slug': ra.slug}) acct = Account.objects.filter(unit__label='CMPT')[0] test_views(self, c, 'ra:', ['edit_account'], {'account_slug': acct.slug}) proj = Project.objects.filter(unit__label='CMPT')[0] test_views(self, c, 'ra:', ['edit_project'], {'project_slug': proj.slug})
def test_redirect(self): """ Redirecting with redirect stub """ crs = CourseOffering.objects.get(slug=TEST_COURSE_SLUG) memb = Member.objects.get(offering=crs, person__userid="ggbaker") p = Page(offering=crs, label="Test") p.save() v = PageVersion(page=p, title="Test Page", wikitext="one +two+ three +four+", editor=memb) v.save() c = Client() # normal pages still viewable url = reverse('offering:pages:view_page', kwargs={'course_slug': crs.slug, 'page_label': 'Test'}) response = c.get(url) self.assertEqual(response.status_code, 200) v = PageVersion(page=p, redirect='NewLocation', editor=memb) v.save() response = c.get(url) self.assertEqual(response.status_code, 301) redir_url = reverse('offering:pages:view_page', kwargs={'course_slug': crs.slug, 'page_label': 'NewLocation'}) self.assertTrue(response['location'].endswith(redir_url))
def test_workflow(self): """ Test the privacy policy workflow and page exclusions """ # clear privacy agreement from test data p = Person.objects.get(userid='dzhao') p.config = {} p.save() client = Client() client.login_user(p.userid) privacy_url = reverse('privacy.views.privacy') # non-role page should still render url = reverse('dashboard.views.index') basic_page_tests(self, client, url) # but role page should redirect to agreement url = reverse('advisornotes.views.advising') response = client.get(url) self.assertRedirects(response, privacy_url + '?next=' + url) # check privacy page basic_page_tests(self, client, privacy_url) # submit and expect recorded agreement response = client.post(privacy_url + '?next=' + url, {'agree': 'on'}) self.assertRedirects(response, url) p = Person.objects.get(userid='dzhao') self.assertTrue(p.config['privacy_signed']) # now we should be able to access basic_page_tests(self, client, url)
def test_course_credits_admin_200_ok(self): raise SkipTest() client = Client() client.login_user("teachadm") url = reverse('planning.views.view_insts_in_unit') response = basic_page_tests(self, client, url) self.assertEqual(response.status_code, 200) url = reverse('planning.views.view_teaching_credits_admin', kwargs={'userid': 'ggbaker'}) response = basic_page_tests(self, client, url) self.assertEqual(response.status_code, 200) url = reverse('planning.views.view_teaching_equivalent_admin', kwargs={'userid': 'ggbaker', 'equivalent_id': 1}) response = basic_page_tests(self, client, url) self.assertEqual(response.status_code, 200) url = reverse('planning.views.new_teaching_equivalent_admin', kwargs={'userid': 'ggbaker'}) response = basic_page_tests(self, client, url) self.assertEqual(response.status_code, 200) url = reverse('planning.views.edit_teaching_equivalent_admin', kwargs={'userid': 'ggbaker', 'equivalent_id': 1}) response = basic_page_tests(self, client, url) self.assertEqual(response.status_code, 200) url = reverse('planning.views.edit_course_offering_credits', kwargs={'userid': 'ggbaker', 'course_slug': TEST_COURSE_SLUG}) response = basic_page_tests(self, client, url) self.assertEqual(response.status_code, 200)
def test_pages(self): offering = CourseOffering.objects.get(slug=TEST_COURSE_SLUG) student = Member.objects.get(offering=offering, person__userid='0aaa0') instr = Member.objects.get(offering=offering, person__userid='ggbaker') c = Client() c.login_user('ggbaker') test_views(self, c, 'offering:discipline:', ['index', 'new', 'newgroup', 'new_nonstudent'], {'course_slug': offering.slug}) cluster = DisciplineGroup(name='TheCluster', offering=offering) cluster.save() case = DisciplineCaseInstrStudent(student=student.person, owner=instr.person, offering=offering, group=cluster) case.save() test_views(self, c, 'offering:discipline:', ['showgroup'], {'course_slug': offering.slug, 'group_slug': cluster.slug}) test_views(self, c, 'offering:discipline:', ['show', 'edit_related', 'edit_attach', 'new_file'], {'course_slug': offering.slug, 'case_slug': case.slug}) # have a look at each form for step in STEP_FORM: test_views(self, c, 'offering:discipline:', ['edit_case_info'], {'course_slug': offering.slug, 'case_slug': case.slug, 'field': step}) # minimally-finish the case so we can check the letter case.letter_sent = 'MAIL' case.letter_text = 'foo' case.save() test_views(self, c, 'offering:discipline:', ['view_letter'], {'course_slug': offering.slug, 'case_slug': case.slug})
def test_api(self): crs = CourseOffering.objects.get(slug=TEST_COURSE_SLUG) memb = Member.objects.get(offering=crs, person__userid="ggbaker") person = Person.objects.get(userid='ggbaker') p = Page(offering=crs, label="PageExists") p.save() v = PageVersion(page=p, title="Page Exists", wikitext="Original Contents", editor=memb, comment="original page") v.save() from dashboard.models import new_feed_token token = new_feed_token() updata = u"""{ "userid": "ggbaker", "token": "%s", "pages": [ { "label": "Index", "title": "The Coursé Page", "can_read": "ALL", "can_write": "INST", "wikitext-base64": "VGhpcyBwYWdlIGlzIHNwZWNpYWwgaW4gKipzb21lKiogd2F5LiBcKHh+XjIrMSA9IFxmcmFjezF9ezJ9XCkuCgpHb29kYnllIHdvcmxkIQ==", "comment": "page creation comment", "use_math": true }, { "label": "PageExists", "new_label": "PageChanged", "title": "Another Page", "can_read": "STUD", "wikitext": "This is some **new** page\\n\\ncontent." } ] }""" % (token) # make a request with no auth token in place c = Client() url = reverse('pages.views.api_import', kwargs={'course_slug': crs.slug}) response = c.post(url, data=updata.encode('utf8'), content_type="application/json") self.assertEquals(response.status_code, 403) # create token and try again person.config['pages-token'] = token person.save() response = c.post(url, data=updata.encode('utf8'), content_type="application/json") self.assertEquals(response.status_code, 200) # make sure the data arrived self.assertEquals(Page.objects.filter(offering=crs, label="PageExists").count(), 0) p = Page.objects.get(offering=crs, label="PageChanged") v = p.current_version() self.assertEqual(v.title, "Another Page") self.assertEqual(v.get_wikitext(), "This is some **new** page\n\ncontent.") p = Page.objects.get(offering=crs, label="Index") v = p.current_version() self.assertEqual(v.title, u"The Cours\u00e9 Page") self.assertEqual(v.get_wikitext(), 'This page is special in **some** way. \\(x~^2+1 = \\frac{1}{2}\\).\n\nGoodbye world!') self.assert_('math' in v.config) self.assertEqual(v.config['math'], True)
def test_grad_letters(self): """ Check handling of letters for grad students """ client = Client() test_auth(client, 'ggbaker') gs = GradStudent.objects.get(person__userid=self.gs_userid) # get template text and make sure substitutions are made lt = LetterTemplate.objects.get(label="Funding") url = reverse('grad.views.get_letter_text', kwargs={'grad_slug': gs.slug, 'letter_template_id': lt.id}) response = client.get(url) self.assertEqual(response.status_code, 200) self.assertContains(response, 'M Grad is making satisfactory progress') content = unicode(response.content) # create a letter with that content l = Letter(student=gs, date=datetime.date.today(), to_lines="The Student\nSFU", template=lt, created_by='ggbaker', content=content) l.save() url = reverse('grad.views.view_letter', kwargs={'grad_slug': gs.slug, 'letter_slug': l.slug}) response = basic_page_tests(self, client, url) self.assertEqual(response.status_code, 200) url = reverse('grad.views.copy_letter', kwargs={'grad_slug': gs.slug, 'letter_slug': l.slug}) response = basic_page_tests(self, client, url) self.assertEqual(response.status_code, 200)
def test_pages(self): """ Basic page rendering """ crs = CourseOffering.objects.get(slug=TEST_COURSE_SLUG) memb = Member.objects.get(offering=crs, person__userid="ggbaker") person = Person.objects.get(userid='ggbaker') p = Page(offering=crs, label="Index") p.save() v = PageVersion(page=p, title="Index Page", wikitext="Original Contents", editor=memb) v.save() p = Page(offering=crs, label="OtherPage") p.save() v = PageVersion(page=p, title="Other Page", wikitext="Original Contents", editor=memb) v.save() c = Client() c.login_user('ggbaker') # test the basic rendering of the core pages test_views(self, c, 'pages.views.', ['index_page', 'all_pages', 'new_page', 'new_file', 'import_site'], {'course_slug': crs.slug}) test_views(self, c, 'pages.views.', ['view_page', 'page_history', 'edit_page', 'import_page'], {'course_slug': crs.slug, 'page_label': 'OtherPage'})
def test_new_nonstudent_post_failure(self): client = Client() client.login_user("dzhao") response = client.post(reverse('advisornotes.views.new_nonstudent'), {'first_name': 'test123'}) self.assertEqual(response.status_code, 200, "Should be brought back to form") q = NonStudent.objects.filter(first_name='test123') self.assertEqual(len(q), 0, "Nonstudent should not have been created")
def test_rest_notes_not_JSON(self): client = Client() f = open('advisornotes/testfiles/rest_notes_valid_file.json') data = f.read() f.close() response = client.post(reverse('advisornotes.views.rest_notes'), data, 'text/plain') self.assertEqual(response.status_code, 415) self.assertEqual(response.content, 'Contents must be JSON (application/json)')
def test_rest_notes_invalid_UTF8(self): client = Client() f = open('advisornotes/testfiles/rest_notes_bad_utf8.json') data = f.read() f.close() response = client.post(reverse('advisornotes.views.rest_notes'), data, 'application/json') self.assertEqual(response.status_code, 400) self.assertEqual(response.content, 'Bad UTF-8 encoded text')
def test_rest_notes_invalid_JSON(self): client = Client() f = open('advisornotes/testfiles/rest_notes_bad_json.json') data = f.read() f.close() response = client.post(reverse('advisornotes.views.rest_notes'), data, 'application/json') self.assertEqual(response.status_code, 400) self.assertEqual(response.content, 'Bad JSON in request body')
def test_rest_notes_missing_credential(self): client = Client() f = open('advisornotes/testfiles/rest_notes_missing_credential.json') data = f.read() f.close() response = client.post(reverse('advisornotes.views.rest_notes'), data, 'application/json') self.assertEqual(response.status_code, 422) self.assertEqual(response.content, "The key 'secret' is not present. ")
def test_that_grad_search_returns_200_ok(self): """ Tests that /grad/search is available. """ client = Client() test_auth(client, 'ggbaker') response = client.get(reverse('grad.views.search')) self.assertEqual(response.status_code, 200)
def test_new_nonstudent_post_success(self): client = Client() client.login_user("dzhao") response = client.post(reverse('advisornotes.views.new_nonstudent'), {'first_name': 'test123', 'last_name': 'test_new_nonstudent_post', 'start_year': 2020}) self.assertEqual(response.status_code, 302, 'Should have been redirected') q = NonStudent.objects.filter(first_name='test123') self.assertEqual(len(q), 1, "There should only be one result") self.assertEqual(q[0].last_name, 'test_new_nonstudent_post')
def test_rest_notes_file_data_not_string(self): client = Client() f = open('advisornotes/testfiles/rest_notes_file_data_not_string.json') data = f.read() f.close() response = client.post(reverse('advisornotes.views.rest_notes'), data, 'application/json') self.assertEqual(response.status_code, 422) self.assertEqual(response.content, "Note file data must be a string")
def test_rest_notes_bad_base64(self): client = Client() f = open('advisornotes/testfiles/rest_notes_bad_base64.json') data = f.read() f.close() response = client.post(reverse('advisornotes.views.rest_notes'), data, 'application/json') self.assertEqual(response.status_code, 422) self.assertEqual(response.content, "Invalid base64 data for note file attachment")
def test_rest_notes_emplid_doesnt_exist(self): client = Client() f = open('advisornotes/testfiles/rest_notes_emplid_doesnt_exist.json') data = f.read() f.close() response = client.post(reverse('advisornotes.views.rest_notes'), data, 'application/json') self.assertEqual(response.status_code, 422) self.assertEqual(response.content, "Emplid '321' doesn't exist")
def test_rest_notes_emplid_not_int(self): client = Client() f = open('advisornotes/testfiles/rest_notes_emplid_not_int.json') data = f.read() f.close() response = client.post(reverse('advisornotes.views.rest_notes'), data, 'application/json') self.assertEqual(response.status_code, 422) self.assertEqual(response.content, "Note emplid must be an integer")
def test_rest_notes_emplid_text_missing(self): client = Client() f = open('advisornotes/testfiles/rest_notes_emplid_missing.json') data = f.read() f.close() response = client.post(reverse('advisornotes.views.rest_notes'), data, 'application/json') self.assertEqual(response.status_code, 422) self.assertEqual(response.content, "Emplid or text not present in note")
def test_rest_notes_empty_list(self): client = Client() f = open('advisornotes/testfiles/rest_notes_empty.json') data = f.read() f.close() response = client.post(reverse('advisornotes.views.rest_notes'), data, 'application/json') self.assertEqual(response.status_code, 422) self.assertEqual(response.content, "No advising notes present")
def DISABLED_test_rest_notes_problem_comments_not_string(self): raise SkipTest() client = Client() f = open('advisornotes/testfiles/rest_notes_problem_comments_not_string.json') data = f.read() f.close() response = client.post(reverse('advisornotes.views.rest_notes'), data, 'application/json') self.assertEqual(response.status_code, 422) self.assertEqual(response.content, "Problem comments must be a string")
def DISABLED_test_rest_notes_problem_unit_invalid(self): raise SkipTest() client = Client() f = open('advisornotes/testfiles/rest_notes_problem_unit_invalid.json') data = f.read() f.close() response = client.post(reverse('advisornotes.views.rest_notes'), data, 'application/json') self.assertEqual(response.status_code, 422) self.assertEqual(response.content, "Unit 'NOTREAL' does not exist")
def DISABLED_test_rest_notes_problem_description_too_long(self): raise SkipTest() client = Client() f = open('advisornotes/testfiles/rest_notes_problem_description_too_long.json') data = f.read() f.close() response = client.post(reverse('advisornotes.views.rest_notes'), data, 'application/json') self.assertEqual(response.status_code, 422) self.assertEqual(response.content, "Problem code & description must be less than or equal to 30 & 50 characters respectively")
def DISABLED_test_rest_notes_problem_fields_missing(self): raise SkipTest() client = Client() f = open('advisornotes/testfiles/rest_notes_problem_fields_missing.json') data = f.read() f.close() response = client.post(reverse('advisornotes.views.rest_notes'), data, 'application/json') self.assertEqual(response.status_code, 422) self.assertEqual(response.content, "Necessary fields not present in problem")
def DISABLED_test_rest_notes_problems_empty(self): raise SkipTest() client = Client() f = open('advisornotes/testfiles/rest_notes_problems_empty.json') data = f.read() f.close() response = client.post(reverse('advisornotes.views.rest_notes'), data, 'application/json') self.assertEqual(response.status_code, 422) self.assertEqual(response.content, "No problems present")
def DISABLED_test_rest_notes_problem_resolution_zero(self): raise SkipTest() client = Client() f = open('advisornotes/testfiles/rest_notes_problem_resolution_zero.json') data = f.read() f.close() response = client.post(reverse('advisornotes.views.rest_notes'), data, 'application/json') self.assertEqual(response.status_code, 422) self.assertEqual(response.content, "Resolution_lasts must be greater than zero")
def test_rest_notes_invalid_token(self): client = Client() f = open('advisornotes/testfiles/rest_notes_invalid_token.json') data = f.read() f.close() response = client.post(reverse('advisornotes.views.rest_notes'), data, 'application/json; charset=utf-8') self.assertEqual(response.status_code, 422) from coredata.validate_rest import _token_not_found self.assertEqual(response.content, _token_not_found)
def test_planning_admin_returns_403_forbidden(self): """ Tests basic page authentication for instructor """ raise SkipTest() client = Client() client.login_user("ggbaker") response = client.get(reverse('planning.views.admin_index')) self.assertEqual(response.status_code, 403)
def test_pages(self): """ Test basic page rendering """ c = Client() c.login_user('ggbaker') test_views(self, c, 'reminders:', ['index', 'create'], {}) rem = Reminder.objects.first() test_views(self, c, 'reminders:', ['view', 'edit'], {'reminder_slug': rem.slug})
def test_grad_letters(self): """ Check handling of letters for grad students """ client = Client() test_auth(client, 'ggbaker') gs = GradStudent.objects.get(person__userid=self.gs_userid) # get template text and make sure substitutions are made lt = LetterTemplate.objects.get(label="Funding") url = reverse('grad.views.get_letter_text', kwargs={ 'grad_slug': gs.slug, 'letter_template_id': lt.id }) response = client.get(url) self.assertEqual(response.status_code, 200) self.assertContains(response, 'M Grad is making satisfactory progress') content = unicode(response.content) # create a letter with that content l = Letter(student=gs, date=datetime.date.today(), to_lines="The Student\nSFU", template=lt, created_by='ggbaker', content=content) l.save() url = reverse('grad.views.view_letter', kwargs={ 'grad_slug': gs.slug, 'letter_slug': l.slug }) response = basic_page_tests(self, client, url) self.assertEqual(response.status_code, 200) url = reverse('grad.views.copy_letter', kwargs={ 'grad_slug': gs.slug, 'letter_slug': l.slug }) response = basic_page_tests(self, client, url) self.assertEqual(response.status_code, 200)
def test_course_browser(self): client = Client() s, c = create_offering() # the main search/filter page url = reverse('browse:browse_courses') response = basic_page_tests(self, client, url) # AJAX request for table data url += '?tabledata=yes&data_type=json&iDisplayStart=0&iDisplayLength=10&iSortingCols=0' response = client.get(url) data = json.loads(response.content.decode('utf8')) self.assertEqual(len(data['aaData']), 10) # courseoffering detail page url = reverse('browse:browse_courses_info', kwargs={'course_slug': TEST_COURSE_SLUG}) response = basic_page_tests(self, client, url)
def test_pages(self): """ Basic page rendering """ crs = self._sample_setup() c = Client() c.login_user('ggbaker') # test the basic rendering of the core pages test_views( self, c, 'offering:pages:', ['index_page', 'all_pages', 'new_page', 'new_file', 'import_site'], {'course_slug': crs.slug}) test_views(self, c, 'offering:pages:', ['view_page', 'page_history', 'edit_page', 'import_page'], { 'course_slug': crs.slug, 'page_label': 'OtherPage' })
def test_pages(self): """ Test basic page rendering """ c = Client() c.login_user('dzhao') test_views(self, c, 'ra:', [ 'search', 'new', 'accounts_index', 'new_account', 'projects_index', 'new_project', 'semester_config', 'browse' ], {}) test_views(self, c, 'ra:', ['found'], {}, qs='search=grad') ra = RAAppointment.objects.filter(unit__label='CMPT')[0] p = ra.person test_views(self, c, 'ra:', ['student_appointments', 'new_student'], {'userid': p.userid}) test_views(self, c, 'ra:', [ 'edit', 'reappoint', 'view', ], {'ra_slug': ra.slug}) # No offer text yet, we should get a redirect when trying to edit the letter text: url = reverse('ra:edit_letter', kwargs={'ra_slug': ra.slug}) response = c.get(url) self.assertEqual(response.status_code, 302) # Let's add some offer text and try again. ra.offer_letter_text = 'Some test text here' ra.save() test_views(self, c, 'ra:', ['edit_letter'], {'ra_slug': ra.slug}) # Make sure we can add attachments test_views(self, c, 'ra:', ['new_attachment'], {'ra_slug': ra.slug}) acct = Account.objects.filter(unit__label='CMPT')[0] test_views(self, c, 'ra:', ['edit_account'], {'account_slug': acct.slug}) proj = Project.objects.filter(unit__label='CMPT')[0] test_views(self, c, 'ra:', ['edit_project'], {'project_slug': proj.slug})
def test_advanced_search_3(self): client = Client() test_auth(client, 'ggbaker') this_sem = Semester.current() units = [ r.unit for r in Role.objects.filter(person__userid='ggbaker', role='GRAD') ] gs = self.__make_test_grad() gs.gradstatus_set.all().delete() s1 = GradStatus(student=gs, status='COMP', start=this_sem.offset(-4)) s1.save() s2 = GradStatus(student=gs, status='ACTI', start=this_sem.offset(-3)) s2.save() s3 = GradStatus(student=gs, status='LEAV', start=this_sem.offset(2)) s3.save() # test current-status searching form = SearchForm( QueryDict('student_status=ACTI&columns=person.emplid')) active_now = form.search_results(units) self.assertIn(gs, active_now) form = SearchForm( QueryDict('student_status=LEAV&columns=person.emplid')) leave_now = form.search_results(units) self.assertNotIn(gs, leave_now) # test status-as-of searching form = SearchForm( QueryDict( 'student_status=ACTI&status_asof=%s&columns=person.emplid' % (this_sem.offset(-4).name))) active_past = form.search_results(units) self.assertNotIn(gs, active_past) form = SearchForm( QueryDict( 'student_status=COMP&status_asof=%s&columns=person.emplid' % (this_sem.offset(-4).name))) applic_past = form.search_results(units) #self.assertIn(gs, applic_past) form = SearchForm( QueryDict( 'student_status=ACTI&status_asof=%s&columns=person.emplid' % (this_sem.offset(3).name))) active_later = form.search_results(units) self.assertNotIn(gs, active_later) form = SearchForm( QueryDict( 'student_status=LEAV&status_asof=%s&columns=person.emplid' % (this_sem.offset(3).name))) leave_later = form.search_results(units) self.assertIn(gs, leave_later)
def setUp(self): self.faketime = 525942870 self.client = Client() # create a Consumer (and associated stuff) try: u = User.objects.get(username='******') except User.DoesNotExist: u = User(username='******') u.save() try: c = Consumer.objects.get(name='Test Consumer') except Consumer.DoesNotExist: c = Consumer(name='Test Consumer') c.description = 'Consumer to do some tests with' c.status = ACCEPTED c.user = u c.xauth_allowed = False c.generate_random_codes() c.save() self.consumer = c i = ConsumerInfo(consumer=c) i.admin_contact = '*****@*****.**' i.permissions = ['courses'] i.timestamp = self.faketime - 10 # make sure the ConsumerInfo was there "before" the Token was created i.save() self.consumerinfo = i # create an access token so we can jump in to requests try: t = Token.objects.get(token_type=Token.ACCESS, consumer=c, user=u) except Token.DoesNotExist: t = Token(token_type=Token.ACCESS, consumer=c, user=u, timestamp=self.faketime) t.is_approved = True t.generate_random_codes() t.verifier = VERIFIER t.save() self.token = t
class TestImportViews(TestCase): fixtures = ['test_data'] def setUp(self): self.c_slug = TEST_COURSE_SLUG self.client = Client() self.c = CourseOffering.objects.get(slug = self.c_slug) self.a1 = NumericActivity(offering = self.c, name = 'test_assignment_1', short_name = 'ta1', status = 'RLS', due_date = datetime.now(), max_grade = 100, position = 0) self.a1.save() def check_student_db_grade(self, grade, s, g): self.assertEquals(grade.member, s) self.assertEquals(grade.value, Decimal(g)) self.assertEquals(grade.flag, 'GRAD') def test_import_view(self): self.client.login_user('ggbaker') # Import the file, check that resulting HTML has correct entries in fields for two affected students url = reverse('marking.views.mark_all_students', kwargs={'course_slug':self.c_slug, 'activity_slug':self.a1.slug}) with open('marking/testfiles/newformat_noprob_userid.csv') as file: post_data = {'import-file-file':[file]} response = self.client.post(url+"?import=true", post_data, follow=True) self.assertEquals(response.status_code, 200) stud1 = Member.objects.get(person = Person.objects.get(userid = '0aaa0'), offering = self.c) stud2 = Member.objects.get(person = Person.objects.get(userid = '0aaa1'), offering = self.c) STUD1_GRADE = '88' STUD2_GRADE = '15' self.assertTrue(re.search(STUD1_GRADE, response.content)) self.assertTrue(re.search(STUD2_GRADE, response.content)) # Submit the grades, check that they were added to DB post_data={'0aaa0-value':STUD1_GRADE, '0aaa1-value':STUD2_GRADE} response = self.client.post(url, post_data, follow=True) self.assertEquals(response.status_code, 200) num_grades = NumericGrade.objects.filter(activity = self.a1).order_by('member__person__userid') self.assertEquals(len(num_grades), 2) self.check_student_db_grade(num_grades[0], stud1, STUD1_GRADE) self.check_student_db_grade(num_grades[1], stud2, STUD2_GRADE)
def test_course_credits_admin_200_ok(self): raise SkipTest() client = Client() client.login_user("teachadm") url = reverse('planning.views.view_insts_in_unit') response = basic_page_tests(self, client, url) self.assertEqual(response.status_code, 200) url = reverse('planning.views.view_teaching_credits_admin', kwargs={'userid': 'ggbaker'}) response = basic_page_tests(self, client, url) self.assertEqual(response.status_code, 200) url = reverse('planning.views.view_teaching_equivalent_admin', kwargs={ 'userid': 'ggbaker', 'equivalent_id': 1 }) response = basic_page_tests(self, client, url) self.assertEqual(response.status_code, 200) url = reverse('planning.views.new_teaching_equivalent_admin', kwargs={'userid': 'ggbaker'}) response = basic_page_tests(self, client, url) self.assertEqual(response.status_code, 200) url = reverse('planning.views.edit_teaching_equivalent_admin', kwargs={ 'userid': 'ggbaker', 'equivalent_id': 1 }) response = basic_page_tests(self, client, url) self.assertEqual(response.status_code, 200) url = reverse('planning.views.edit_course_offering_credits', kwargs={ 'userid': 'ggbaker', 'course_slug': TEST_COURSE_SLUG }) response = basic_page_tests(self, client, url) self.assertEqual(response.status_code, 200)
class TestImportViewsLet(TestCase): fixtures = ['basedata', 'coredata', 'grades'] def setUp(self): self.c_slug = TEST_COURSE_SLUG self.client = Client() self.c = CourseOffering.objects.get(slug = self.c_slug) self.a1 = LetterActivity(offering = self.c, name = 'test_assignment_1_let', short_name = 'tal1', status = 'RLS', due_date = datetime.now(), position = 0) self.a1.save() def check_student_db_grade(self, grade, s, g): self.assertEqual(grade.member, s) self.assertEqual(grade.letter_grade, g) self.assertEqual(grade.flag, 'GRAD') def test_import_view_let(self): self.client.login_user('ggbaker') # Import the file, check that resulting HTML has correct entries in fields for two affected students url = reverse('offering:mark_all_students', kwargs={'course_slug':self.c_slug, 'activity_slug':self.a1.slug}) with open('marking/testfiles/newformat_noprob_userid_let.csv') as file: post_data = {'import-file-file':[file]} response = self.client.post(url+"?import=true", post_data, follow=True) self.assertEqual(response.status_code, 200) stud1 = Member.objects.get(person = Person.objects.get(userid = '0aaa0'), offering = self.c) stud2 = Member.objects.get(person = Person.objects.get(userid = '0aaa1'), offering = self.c) STUD1_GRADE = 'A' STUD2_GRADE = 'C-' self.assertContains(response, b'value="%b"' % (STUD1_GRADE.encode('utf8'),)) self.assertContains(response, b'value="%b"' % (STUD2_GRADE.encode('utf8'),)) # Submit the grades, check that they were added to DB post_data={'0aaa0-value':STUD1_GRADE, '0aaa1-value':STUD2_GRADE} response = self.client.post(url, post_data, follow=True) self.assertEqual(response.status_code, 200) let_grades = LetterGrade.objects.filter(activity = self.a1).order_by('member__person__userid') self.assertEqual(len(let_grades), 2) self.check_student_db_grade(let_grades[0], stud1, STUD1_GRADE) self.check_student_db_grade(let_grades[1], stud2, STUD2_GRADE)
def test_course_credits_inst_200_ok(self): raise SkipTest() client = Client() client.login_user("ggbaker") url = reverse('planning.views.view_teaching_credits_inst') response = basic_page_tests(self, client, url) self.assertEqual(response.status_code, 200) url = reverse('planning.views.view_teaching_equivalent_inst', kwargs={'equivalent_id': 1}) response = basic_page_tests(self, client, url) self.assertEqual(response.status_code, 200) url = reverse('planning.views.new_teaching_equivalent_inst') response = basic_page_tests(self, client, url) self.assertEqual(response.status_code, 200) url = reverse('planning.views.edit_teaching_equivalent_inst', kwargs={'equivalent_id': 1}) response = basic_page_tests(self, client, url) self.assertEqual(response.status_code, 200)
def test_submission_types(self): "Minimally test each submission type" offering = CourseOffering.objects.get(slug=TEST_COURSE_SLUG) activity = Activity.objects.get(offering=offering, slug='rep') activity.due_date = datetime.datetime.now() + datetime.timedelta( days=1) # make sure it's submittable activity.save() client = Client() # instructor views client.login_user("ggbaker") for Type in ALL_TYPE_CLASSES: label = Type.label test_views(self, client, 'offering:submission:', ['add_component'], { 'course_slug': offering.slug, 'activity_slug': activity.slug }, qs='type=' + label)
def setUp(self): self.c_slug = TEST_COURSE_SLUG self.client = Client() self.c = CourseOffering.objects.get(slug = self.c_slug) self.a1 = NumericActivity(offering = self.c, name = 'test_assignment_1', short_name = 'ta1', status = 'RLS', due_date = datetime.now(), max_grade = 100, position = 0) self.a1.save() self.students = self.c.members.filter(person__role='STUD') self.userids = [p.userid for p in self.students] self.emplids = [p.emplid for p in self.students]
def test_workflow(self): """ Test the privacy policy workflow and page exclusions """ # clear privacy agreement from test data p = Person.objects.get(userid='dzhao') p.config = {} p.save() client = Client() client.login_user(p.userid) privacy_url = reverse('config:privacy') # non-role page should still render url = reverse('dashboard:index') basic_page_tests(self, client, url) # but role page should redirect to agreement url = reverse('advising:advising') response = client.get(url) self.assertRedirects(response, privacy_url + '?next=' + url) # check privacy page basic_page_tests(self, client, privacy_url) # submit and expect recorded agreement response = client.post(privacy_url + '?next=' + url, {'agree': 'on'}) self.assertRedirects(response, url) p = Person.objects.get(userid='dzhao') self.assertTrue(p.config['privacy_signed']) # now we should be able to access basic_page_tests(self, client, url)
def test_pages(self): """ Render as many pages as possible, to make sure they work, are valid, etc. """ c = Client() c.login_user('ggbaker') # test as an instructor test_views(self, c, 'offering:quiz:', ['index', 'preview_student', 'edit', 'question_add', 'submissions', 'special_cases', 'special_case_add', 'marking', 'strange_history', 'photo_compare'], {'course_slug': self.offering.slug, 'activity_slug': self.activity.slug}) test_views(self, c, 'offering:quiz:', ['question_add_version'], {'course_slug': self.offering.slug, 'activity_slug': self.activity.slug, 'question_id': str(self.q1.id)}) test_views(self, c, 'offering:quiz:', ['question_edit'], {'course_slug': self.offering.slug, 'activity_slug': self.activity.slug, 'question_id': str(self.q1.id), 'version_id': str(self.v11.id)}) test_views(self, c, 'offering:quiz:', ['question_edit'], {'course_slug': self.offering.slug, 'activity_slug': self.activity.slug, 'question_id': str(self.q2.id), 'version_id': str(self.v21.id)}) test_views(self, c, 'offering:quiz:', ['view_submission', 'submission_history'], {'course_slug': self.offering.slug, 'activity_slug': self.activity.slug, 'userid': self.s1.person.userid}) test_views(self, c, 'offering:quiz:', ['mark_student'], {'course_slug': self.offering.slug, 'activity_slug': self.activity.slug, 'member_id': self.s1.id}) # test as a student c.login_user(self.s0.person.userid) test_views(self, c, 'offering:quiz:', ['index'], {'course_slug': self.offering.slug, 'activity_slug': self.activity.slug})
def test_pages(self): client = Client() account_slug = 'cmpt-234-sfufa-account' contract_slug = 'a-test-sessionalcontract' contract = SessionalContract.objects.get(slug=contract_slug) contract_id = contract.id # as instructor client.login_user('dzhao') test_views(self, client, 'sessionals:', [ 'sessionals_index', 'manage_accounts', 'new_account', 'manage_configs', 'new_config', 'new_contract' ], {}) test_views(self, client, 'sessionals:', ['edit_account', 'view_account'], {'account_slug': account_slug}) test_views(self, client, 'sessionals:', ['view_contract', 'edit_contract'], {'contract_slug': contract_slug}) url = reverse('sessionals:delete_contract', kwargs={'contract_id': contract_id}) response = client.post(url, follow=True) self.assertEquals(response.status_code, 200)
def test_dst(self): """ Test news item in the ambiguous DST switchover """ instr = self.instructor n = NewsItem(user=instr, author=instr, source_app='foo', title='The Title', content='Content') n.save() c = Client() c.login_user(instr.userid) test_views(self, c, '', ['dashboard:index', 'news:news_list'], {}) n.published = datetime.datetime( 2014, 11, 2, 1, 30, 0) # there are two of this time because of the DST transition n.save() test_views(self, c, '', ['dashboard:index', 'news:news_list'], {})
def test_pages(self): """ Basic page rendering """ crs = CourseOffering.objects.get(slug=TEST_COURSE_SLUG) memb = Member.objects.get(offering=crs, person__userid="ggbaker") person = Person.objects.get(userid='ggbaker') p = Page(offering=crs, label="Index") p.save() v = PageVersion(page=p, title="Index Page", wikitext="Original Contents", editor=memb) v.save() p = Page(offering=crs, label="OtherPage") p.save() v = PageVersion(page=p, title="Other Page", wikitext="Original Contents", editor=memb) v.save() c = Client() c.login_user('ggbaker') # test the basic rendering of the core pages test_views( self, c, 'pages.views.', ['index_page', 'all_pages', 'new_page', 'new_file', 'import_site'], {'course_slug': crs.slug}) test_views(self, c, 'pages.views.', ['view_page', 'page_history', 'edit_page', 'import_page'], { 'course_slug': crs.slug, 'page_label': 'OtherPage' })
def test_timing(self): """ Ensure that the quiz timing rules are enforced for students """ c = Client() c.login_user(self.s0.person.userid) url = reverse('offering:quiz:index', kwargs={'course_slug': self.offering.slug, 'activity_slug': self.activity.slug}) # quiz created in .setUp() is ongoing response = c.get(url) self.assertTemplateUsed(response, 'quizzes/index_student.html') self.assertEqual(response.status_code, 200) # quiz in the future shouldn't be visible self.quiz.start = now + hour self.quiz.end = now + 2*hour self.quiz.save() response = c.get(url) self.assertTemplateUsed(response, 'quizzes/unavailable.html') self.assertEqual(response.status_code, 403) # neither should a quiz in the past self.quiz.start = now - 2*hour self.quiz.end = now - hour self.quiz.save() response = c.get(url) self.assertTemplateUsed(response, 'quizzes/unavailable.html') self.assertEqual(response.status_code, 403) # but the student with the special case has it honoured c.login_user(self.s1.person.userid) response = c.get(url) self.assertTemplateUsed(response, 'quizzes/index_student.html') self.assertEqual(response.status_code, 200)
def test_grad_quicksearch(self): """ Tests grad quicksearch (index page) functionality """ client = Client() client.login_user('dzhao') response = client.get(reverse('grad.views.index')) self.assertEqual(response.status_code, 200) # AJAX calls for autocomplete return JSON response = client.get( reverse('grad.views.quick_search') + '?term=grad') self.assertEqual(response.status_code, 200) self.assertEqual(response['content-type'], 'application/json') # get this grad's slug from the search autocomplete = json.loads(response.content) grad_slug = [ d['value'] for d in autocomplete if d['value'].startswith(self.gs_userid) ][0] # search submit with gradstudent slug redirects to page response = client.get( reverse('grad.views.quick_search') + '?search=' + grad_slug) self.assertEqual(response.status_code, 302) self.assertTrue(response['location'].endswith( reverse('grad.views.view', kwargs={'grad_slug': grad_slug}))) # search submit with non-slug redirects to "did you mean" page response = client.get( reverse('grad.views.quick_search') + '?search=' + self.gs_userid) self.assertEqual(response.status_code, 302) self.assertTrue(response['location'].endswith( reverse('grad.views.not_found') + "?search=" + self.gs_userid)) response = client.get(response['location']) gradlist = response.context['grads'] self.assertEqual( len(gradlist), GradStudent.objects.filter(person__userid=self.gs_userid).count()) self.assertIn(self.gs, gradlist)
def test_redirect(self): """ Redirecting with redirect stub """ crs = CourseOffering.objects.get(slug=TEST_COURSE_SLUG) memb = Member.objects.get(offering=crs, person__userid="ggbaker") p = Page(offering=crs, label="Test") p.save() v = PageVersion(page=p, title="Test Page", wikitext="one +two+ three +four+", editor=memb) v.save() c = Client() # normal pages still viewable url = reverse('offering:pages:view_page', kwargs={ 'course_slug': crs.slug, 'page_label': 'Test' }) response = c.get(url) self.assertEqual(response.status_code, 200) v = PageVersion(page=p, redirect='NewLocation', editor=memb) v.save() response = c.get(url) self.assertEqual(response.status_code, 301) redir_url = reverse('offering:pages:view_page', kwargs={ 'course_slug': crs.slug, 'page_label': 'NewLocation' }) self.assertTrue(response['location'].endswith(redir_url))
def test_roles(self): # create person an give sysadmin role p1 = Person(emplid=210012345, userid="test1", last_name="Lname", first_name="Fname", pref_first_name="Fn", middle_name="M") p1.save() unit = Unit.objects.get(label="UNIV") r = Role(person=p1, role="SYSA", unit=unit, expiry=TEST_ROLE_EXPIRY) r.save() self.assertEqual(str(r), "Lname, Fname (System Administrator, UNIV)") # check the front end client = Client() client.login_user("test1") url = reverse('sysadmin:role_list') response = basic_page_tests(self, client, url) self.assertContains( response, 'Lname, Fname</a></td>\n <td>System Administrator</td>') # add a new role with the front end oldcount = Role.objects.filter(role='FAC').count() url = reverse('sysadmin:new_role') response = basic_page_tests(self, client, url) response = client.post(url, { 'person': '33333333', 'role': 'FAC', 'unit': 2 }) self.assertEqual(response.status_code, 200) validate_content(self, response.content, url) self.assertTrue( b"could not import DB2 module" in response.content or b"could not connect to reporting database" in response.content or b"Could not find this emplid." in response.content or b"Reporting database access has been disabled" in response.content or b"Could not communicate with reporting database" in response.content) response = client.post( url, { 'person': p1.emplid, 'role': 'FAC', 'unit': unit.id, 'expiry': str(TEST_ROLE_EXPIRY) }) self.assertEqual(response.status_code, 302) # make sure the role is now there self.assertEqual(Role.objects.filter(role='FAC').count(), oldcount + 1)
def test_inaccessible_pages(self): client = Client() # First, without logging in: url = reverse('outreach:outreach_index') response = client.get(url) self.assertEqual(response.status_code, 302) # Now log in but without the correct role client.login_user('pba7') response = client.get(url) self.assertEqual(response.status_code, 403)
def test_inaccessible_pages(self): client = Client() contract_id = 1 url = reverse('sessionals:sessionals_index') response = client.get(url) self.assertEquals(response.status_code, 302) # Now log in but without the correct role client.login_user('foo') response = client.get(url) self.assertEquals(response.status_code, 403) url = reverse('sessionals:delete_contract', kwargs={'contract_id': contract_id}) response = client.post(url, follow=True) self.assertEquals(response.status_code, 403)
def test_grad_status(self): client = Client() test_auth(client, 'ggbaker') this_sem = Semester.current() # clear the deck on this student's statuses gs = self.__make_test_grad() gs.gradstatus_set.all().delete() s1 = GradStatus(student=gs, status='COMP', start=this_sem.offset(-4)) s1.save() s2 = GradStatus(student=gs, status='ACTI', start=this_sem.offset(-3)) s2.save() s3 = GradStatus(student=gs, status='LEAV', start=this_sem.offset(2)) s3.save() gs = GradStudent.objects.get( id=gs.id) # make sure we get what's in the database now self.assertEqual(gs.current_status, 'ACTI') # check status in a particular semester results self.assertEqual(gs.status_as_of(this_sem.offset(-6)), None) self.assertEqual(gs.status_as_of(this_sem.offset(-4)), 'COMP') self.assertEqual(gs.status_as_of(this_sem.offset(-3)), 'ACTI') self.assertEqual(gs.status_as_of(this_sem), 'ACTI') self.assertEqual(gs.status_as_of(this_sem.offset(1)), 'ACTI') self.assertEqual(gs.status_as_of(this_sem.offset(2)), 'LEAV') self.assertEqual(gs.status_as_of(this_sem.offset(3)), 'LEAV') # grad.tasks.update_statuses_to_current will put this student on LEAV on the first day of that future semester # check that "active" statuses are preferred over "applicant" statuses in status calcs s4 = GradStatus(student=gs, status='COMP', start=this_sem.offset(-3)) s4.save() self.assertEqual(gs.status_as_of(this_sem.offset(-3)), 'ACTI') # because of insanity that makes strange sense, application-decision statuses propagate back a semester gs.gradstatus_set.all().delete() s1 = GradStatus(student=gs, status='COMP', start=this_sem) s1.save() s2 = GradStatus(student=gs, status='REJE', start=this_sem.offset(1)) s2.save() self.assertEqual(gs.status_as_of(this_sem.offset(-1)), 'COMP') self.assertEqual(gs.status_as_of(this_sem), 'REJE') self.assertEqual(gs.status_as_of(this_sem.offset(1)), 'REJE')
def test_inaccessible_pages(self): client = Client() # First, without logging in: url = reverse('space:index') response = client.get(url) self.assertEqual(response.status_code, 302) # Now log in but without the correct role client.login_user('pba7') response = client.get(url) self.assertEqual(response.status_code, 403) # We darn well better not be able to delete anything without the proper role: url = reverse('space:delete_booking', kwargs={'booking_id': self.booking.id}) response = client.post(url, follow=True) self.assertEqual(response.status_code, 403) url = reverse('space:delete_location', kwargs={'location_id': self.location.id}) response = client.post(url, follow=True) self.assertEqual(response.status_code, 403) url = reverse('space:delete_roomtype', kwargs={'roomtype_id': self.roomtype.id}) response = client.post(url, follow=True) self.assertEqual(response.status_code, 403)
def test_pages(self): person = Person.objects.filter()[0] c = Client() # as instructor c.login_user(person.userid) test_views(self, c, 'dashboard.views.', ['index', 'index_full', 'news_list', 'config', 'calendar', 'create_calendar_url', 'disable_calendar_url', 'news_config', 'create_news_url', 'disable_news_url', 'list_docs', 'photo_agreement'], {}) test_views(self, c, 'dashboard.views.', ['view_doc'], {'doc_slug': 'impersonate'}) # admin views for signatures r = Role.objects.filter(role='ADMN')[0] c.login_user(r.person.userid) test_views(self, c, 'dashboard.views.', ['signatures', 'new_signature'], {})
def test_annual_teaching(self): """ Test the annual teaching value entry field """ person = Person.objects.get(userid='ggbaker') unit = Unit.objects.get(slug='cmpt') editor = Person.objects.get(userid='dzhao') etype = 'NORM_TEACH' event = CareerEvent.objects.filter(unit=unit, person=person, event_type=etype)[0] event.config[ 'load'] = 2 # 2 courses/semester in database should be 6/year to the user event.get_handler().save(editor) c = Client() c.login_user(editor.userid) # make sure the form renders with value="6" url = reverse('faculty:change_event', kwargs={ 'userid': person.userid, 'event_slug': event.slug }) resp = c.get(url) inputs = [l for l in resp.content.split(b'\n') if b'name="load"' in l] inputs_correct_value = [l for l in inputs if b'value="6"' in l] self.assertEqual(len(inputs_correct_value), 1) # POST a change and make sure the right value ends up in the DB data = { 'start_date_0': '2000-09-01', 'end_date_0': '', 'unit': str(unit.id), 'load': '5', 'comments': '', } c.post(url, data) new_ce = CareerEvent.objects.filter(unit=unit, person=person, event_type=etype)[0] self.assertEqual(new_ce.config['load'], '5/3')
def test_pages(self): c = Client() # TUG/instructor views c.login_user('dzhao') offering = CourseOffering.objects.get(slug=TEST_COURSE_SLUG) ta = Member.objects.filter(offering=offering, role="TA")[0] test_views(self, c, 'offering:', ['new_tug'], {'course_slug': offering.slug, 'userid': ta.person.userid}) # create TUG to view/edit tug = TUG(member=ta, base_units=5) for f in tug.config_meta.keys(): tug.config[f] = {'weekly': 1, 'total': 13, 'note': 'somenote'} tug.save() test_views(self, c, 'offering:', ['view_tug', 'edit_tug'], {'course_slug': offering.slug, 'userid': ta.person.userid}) # admin views c.login_user('dzhao') test_views(self, c, 'tugs:', ['all_tugs_admin'], {}) test_views(self, c, 'ta:', ['view_postings'], {}) post = TAPosting.objects.filter(unit__label='CMPT')[0] test_views(self, c, 'ta:', ['new_application', 'new_application_manual', 'view_all_applications', 'print_all_applications', 'print_all_applications_by_course', 'view_late_applications', 'assign_tas', 'all_contracts'], {'post_slug': post.slug}) test_views(self, c, 'ta:', ['assign_bus'], {'post_slug': post.slug, 'course_slug': offering.slug}) contr = TAContract.objects.filter(posting=post)[0] test_views(self, c, 'ta:', ['edit_application', 'view_application', 'preview_offer', 'view_contract', 'edit_contract'], {'post_slug': post.slug, 'userid': contr.application.person.userid}) # applicant views c.login_user(contr.application.person.userid) test_views(self, c, 'ta:', ['accept_contract'], {'post_slug': post.slug, 'userid': contr.application.person.userid})
def test_course_page(self): """ Check out a course front-page """ _, c = create_offering() client = Client() # not logged in: should be redirected to login page response = client.get(c.get_absolute_url()) self.assertEquals(response.status_code, 302) # log in as student "0aaa0" client.login_user("0aaa0") p = Person.objects.get(userid="0aaa0") # not in the course: should get 403 Forbidden response = client.get(c.get_absolute_url()) self.assertEquals(response.status_code, 403) # add to course and try again m = Member(person=p, offering=c, role="STUD", credits=3, career="UGRD", added_reason="UNK") m.save() response = client.get(c.get_absolute_url()) self.assertEquals(response.status_code, 200) validate_content(self, response.content, c.get_absolute_url()) # dropped students should be forbidden m.role = "DROP" m.save() response = client.get(c.get_absolute_url()) self.assertEquals(response.status_code, 403)
def test_form_submission(self): """ Check that submitting the page editing form results in the objects we expect. """ crs = self._sample_setup() c = Client() c.login_user('ggbaker') pg = Page.objects.get(offering=crs, label="Index") url = reverse('offering:pages:edit_page', kwargs={ 'course_slug': crs.slug, 'page_label': pg.label }) form_data = { 'offering': crs.id, 'label': 'NewIndex', 'can_read': 'ALL', 'can_write': 'INST', 'releasedate': '', 'title': 'New Index', 'markup_content_0': 'Unsafe <script>HTML</script>', 'markup_content_1': 'html', 'markup_content_2': 'on', 'comment': 'the comment', } # bad submission: redisplay form resp = c.post(url, {}) self.assertEqual(resp.status_code, 200) # good submission: save and redirect resp = c.post(url, form_data) self.assertEqual(resp.status_code, 302) pg = Page.objects.get(offering=crs, label="NewIndex") vr = pg.current_version() self.assertEqual(pg.can_write, 'INST') self.assertEqual(vr.title, 'New Index') self.assertEqual(vr.wikitext, 'Unsafe HTML') # should be cleaned on the way in self.assertEqual(vr.config['markup'], 'html') self.assertEqual(vr.config['math'], True)