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)
