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.assertEqual(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.assertEqual(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.assertEqual(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.assertEqual(response.status_code, 403)
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):
"""
Test basic page rendering
"""
c = Client()
c.login_user('dzhao')
test_views(self, c, 'ra.views.', [
'search', 'new', 'accounts_index', 'new_account', 'projects_index',
'new_project', 'semester_config', 'browse'
], {})
test_views(self, c, 'ra.views.', ['found'], {}, qs='search=grad')
ra = RAAppointment.objects.filter(unit__label='CMPT')[0]
p = ra.person
test_views(self, c, 'ra.views.',
['student_appointments', 'new_student'],
{'userid': p.userid})
test_views(self, c, 'ra.views.', [
'edit',
'reappoint',
'view',
], {'ra_slug': ra.slug})
test_views(self, c, 'ra.views.', ['edit_letter'], {'ra_slug': ra.slug})
acct = Account.objects.filter(unit__label='CMPT')[0]
test_views(self, c, 'ra.views.', ['edit_account'],
{'account_slug': acct.slug})
proj = Project.objects.filter(unit__label='CMPT')[0]
test_views(self, c, 'ra.views.', ['edit_project'],
{'project_slug': proj.slug})
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()
client.login_user('dzhao')
this_sem = Semester.current()
units = [
r.unit for r in Role.objects_fresh.filter(person__userid='dzhao',
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()
gs.update_status_fields()
# 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)
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_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.assertEqual(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.assertEqual(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.assertEqual(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.assertEqual(response.status_code, 403)
def test_pages(self):
client = Client()
today = datetime.date.today()
long_start = today + datetime.timedelta(days=5 * 365)
# Our test even is probably the only one that starts at least 5 years from whatever day it is when we run this
event = OutreachEvent.objects.current([
Unit.objects.get(slug='cmpt')
]).filter(start_date__gt=long_start).first()
registration = OutreachEventRegistration.objects.filter(
event=event).first()
# Anyone should be able to register
test_views(self, client, 'outreach:', ['register', 'register_success'],
{'event_slug': event.slug})
# Log in as someone with the correct role.
userid = Role.objects_fresh.filter(
role='OUTR', unit=Unit.objects.get(slug='cmpt'))[0].person.userid
client.login_user(userid)
test_views(self, client, 'outreach:',
['outreach_index', 'view_all_registrations'], {})
test_views(self, client, 'outreach:',
['edit_event', 'view_event', 'view_event_registrations'],
{'event_slug': event.slug})
test_views(self, client, 'outreach:',
['view_registration', 'edit_registration'],
{'registration_id': registration.id})
url = reverse('outreach:toggle_registration_attendance',
kwargs={'registration_id': registration.id})
response = client.post(url, follow=True)
self.assertEqual(response.status_code, 200)
def test_inaccessible_pages(self):
# Presumably, our booking that starts more than 5 years ago is the one generated in the fixtures. If there are
# others that old, it should at least be the first.
unit = Unit.objects.get(slug='cmpt')
booking = BookingRecord.objects.filter(start_time__lte=self.long_start, location__unit=unit).first()
location = booking.location
roomtype = location.room_type
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': booking.id})
response = client.post(url, follow=True)
self.assertEqual(response.status_code, 403)
url = reverse('space:delete_location', kwargs={'location_id': location.id})
response = client.post(url, follow=True)
self.assertEqual(response.status_code, 403)
url = reverse('space:delete_roomtype', kwargs={'roomtype_id': roomtype.id})
response = client.post(url, follow=True)
self.assertEqual(response.status_code, 403)
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_pages(self):
# Presumably, our booking that starts more than 5 years ago is the one generated in the fixtures. If there are
# others that old, it should at least be the first.
unit = Unit.objects.get(slug='cmpt')
booking = BookingRecord.objects.filter(start_time__lte=self.long_start, location__unit=unit).first()
location = booking.location
roomtype = location.room_type
client = Client()
userid = Role.objects_fresh.filter(role='SPAC', unit=unit)[0].person.userid
client.login_user(userid)
test_views(self, client, 'space:', ['index', 'list_roomtypes', 'add_roomtype', 'manage_safety_items',
'add_safety_item'], {})
test_views(self, client, 'space:', ['view_location', 'edit_location', 'add_booking'],
{'location_slug': location.slug})
test_views(self, client, 'space:', ['view_roomtype', 'edit_roomtype'], {'roomtype_slug': roomtype.slug})
test_views(self, client, 'space:', ['view_booking', 'edit_booking', 'add_booking_attachment'],
{'booking_slug': booking.slug})
# Now, we should be able to delete stuff properly.
url = reverse('space:delete_booking', kwargs={'booking_id': booking.id})
response = client.post(url, follow=True)
self.assertEqual(response.status_code, 200)
url = reverse('space:delete_location', kwargs={'location_id': location.id})
response = client.post(url, follow=True)
self.assertEqual(response.status_code, 200)
url = reverse('space:delete_roomtype', kwargs={'roomtype_id': roomtype.id})
response = client.post(url, follow=True)
self.assertEqual(response.status_code, 200)
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_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_new_nonstudent_post_failure(self):
client = Client()
client.login_user("dzhao")
response = client.post(reverse('advising: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_grad_pages(self):
"""
Check overall pages for the grad module and make sure they all load
"""
client = Client()
client.login_user('dzhao')
gs = self.__make_test_grad()
prog = gs.program
GradRequirement(program=prog,
description="Some New Requirement").save()
Supervisor(student=GradStudent.objects.all()[0],
supervisor=Person.objects.get(userid='ggbaker'),
supervisor_type='SEN').save()
lt = LetterTemplate(
unit=gs.program.unit,
label='Template',
content="This is the\n\nletter for {{first_name}}.")
lt.save()
test_views(self, client, 'grad.views.', [
'programs', 'new_program', 'requirements', 'new_requirement',
'letter_templates', 'new_letter_template',
'manage_scholarshipType', 'search', 'funding_report',
'all_promises'
], {})
test_views(self, client, 'grad.views.', ['manage_letter_template'],
{'letter_template_slug': lt.slug})
test_views(self,
client,
'grad.views.', ['not_found'], {},
qs='search=grad')
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_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):
"""
Test basic page rendering
"""
c = Client()
c.login_user('dzhao')
test_views(self, c, 'ra:', ['dashboard', 'new_request', 'browse'], {})
ra = RAAppointment.objects.filter(unit__label='CMPT')[0]
p = ra.person
test_views(self, c, 'ra:', ['edit', '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})
# NEW RA
# test basic pages
test_views(self, c, 'ra:', [
'browse_appointments', 'new_request', 'dashboard',
'active_appointments', 'advanced_search'
], {})
# test search
test_views(self, c, 'ra:',
['appointee_appointments', 'supervisor_appointments'],
{'userid': p.userid})
# create test rarequest
u = Unit.objects.get(slug='cmpt')
s = Person.objects.get(userid='dzhao')
req = RARequest(person=p,
unit=u,
author=s,
supervisor=s,
config={},
hiring_category='RA',
start_date=date(2021, 6, 1),
end_date=date(2021, 9, 1),
total_pay=1000)
req.save()
# test pages associated with an rarequest
test_views(self, c, 'ra:', [
'view_request', 'edit_request', 'reappoint_request',
'edit_request_notes', 'request_paf', 'request_offer_letter_update',
'new_admin_attachment'
], {'ra_slug': req.slug})
def test_new_nonstudent_post_success(self):
client = Client()
client.login_user("dzhao")
response = client.post(reverse('advising: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_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_that_grad_search_returns_200_ok(self):
"""
Tests that /grad/search is available.
"""
client = Client()
client.login_user('dzhao')
response = client.get(reverse('grad.views.search'))
self.assertEqual(response.status_code, 200)
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_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_that_grad_search_with_csv_option_returns_csv(self):
client = Client()
client.login_user('dzhao')
response = client.get(reverse('grad.views.search'), {
'columns': 'person.first_name',
'csv': 'sure'
})
self.assertEqual(response.status_code, 200)
self.assertEqual(response['Content-Type'], 'text/csv')
class TestImportViews(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 = 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.assertEqual(grade.member, s)
self.assertEqual(grade.value, Decimal(g))
self.assertEqual(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('offering: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.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 = '88'
STUD2_GRADE = '15'
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)
num_grades = NumericGrade.objects.filter(
activity=self.a1).order_by('member__person__userid')
self.assertEqual(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_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_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_pages(self):
"Test a bunch of page views"
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")
component1 = URL.Component(activity=activity, title='Sample URL 1', description='Please submit some URL.',
check=False, prefix='')
component1.save()
component2 = URL.Component(activity=activity, title='Sample URL 2', description='Please submit some URL.',
check=False, prefix='')
component2.save()
test_views(self, client, 'submission.views.', ['show_components', 'add_component'],
{'course_slug': offering.slug, 'activity_slug': activity.slug})
url = reverse('submission.views.edit_single', kwargs={'course_slug': offering.slug, 'activity_slug': activity.slug}) \
+ '?id=' + unicode(component1.id)
basic_page_tests(self, client, url)
url = reverse('submission.views.add_component', kwargs={'course_slug': offering.slug, 'activity_slug': activity.slug}) \
+ '?type=url'
basic_page_tests(self, client, url)
# student views: with none, some, and all submitted
client.login_user("0aaa0")
# test various permutations of success to make sure everything returns okay
name1 = '%i-url' % (component1.id)
name2 = '%i-url' % (component2.id)
submissions = [
({}, False),
({name1: '', name2: ''}, False),
({name1: '', name2: 'do i look like a url to you?'}, False),
({name1: 'http://www.sfu.ca/', name2: ''}, False),
({name1: 'http://www.cs.sfu.ca/', name2: 'http://example.com/'}, True),
({name1: 'http://www.sfu.ca/', name2: 'http://example.com/'}, True),
]
for submitdata, redir in submissions:
test_views(self, client, 'submission.views.', ['show_components', 'show_components_submission_history'],
{'course_slug': offering.slug, 'activity_slug': activity.slug})
url = reverse('submission.views.show_components', kwargs={'course_slug': offering.slug, 'activity_slug': activity.slug})
response = client.post(url, submitdata)
if redir:
# success: we expect a redirect
self.assertEqual(response.status_code, 302)
else:
# some problems: expect a page reporting that
self.assertEqual(response.status_code, 200)
validate_content(self, response.content, url)
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_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()
# 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_pages(self):
client = Client()
asset_slug = 'cmpt-something'
asset_id = 1
client.login_user('dzhao')
test_views(self, client, 'inventory:',
['inventory_index', 'new_asset'], {})
test_views(self, client, 'inventory:', ['edit_asset', 'view_asset'],
{'asset_slug': asset_slug})
url = reverse('inventory:delete_asset', kwargs={'asset_id': asset_id})
response = client.post(url, follow=True)
self.assertEquals(response.status_code, 200)
class TestImportViewsLet(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 = 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.assertEquals(grade.member, s)
self.assertEquals(grade.letter_grade, g)
self.assertEquals(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('marking.views.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.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 = 'A'
STUD2_GRADE = 'C-'
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)
let_grades = LetterGrade.objects.filter(
activity=self.a1).order_by('member__person__userid')
self.assertEquals(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_group_submission_view(self):
"""
test if group submission can be viewed by group member and non group member
"""
now = datetime.datetime.now()
_, course = create_offering()
a1 = NumericActivity(name="Assignment 1", short_name="A1", status="RLS", offering=course, position=2, max_grade=15, due_date=now, group=True)
a1.save()
a2 = NumericActivity(name="Assignment 2", short_name="A2", status="RLS", offering=course, position=1, max_grade=15, due_date=now, group=True)
a2.save()
p = Person.objects.get(userid="ggbaker")
member = Member(person=p, offering=course, role="INST", career="NONS", added_reason="UNK")
member.save()
c1 = URL.Component(activity=a1, title="URL Link", position=8)
c1.save()
c2 = Archive.Component(activity=a1, title="Archive File", position=1, max_size=100000)
c2.save()
c3 = Code.Component(activity=a1, title="Code File", position=3, max_size=2000, allowed=".py")
c3.save()
userid1 = "0aaa0"
userid2 = "0aaa1"
userid3 = "0aaa2"
for u in [userid1, userid2,userid3]:
p = Person.objects.get(userid=u)
m = Member(person=p, offering=course, role="STUD", credits=3, career="UGRD", added_reason="UNK")
m.save()
m = Member.objects.get(person__userid=userid1, offering=course)
g = Group(name="Test Group", manager=m, courseoffering=course)
g.save()
gm = GroupMember(group=g, student=m, confirmed=True, activity=a1)
gm.save()
gm = GroupMember(group=g, student=m, confirmed=True, activity=a2)
gm.save()
m = Member.objects.get(person__userid=userid2, offering=course)
gm = GroupMember(group=g, student=m, confirmed=True, activity=a1)
gm.save()
gm = GroupMember(group=g, student=m, confirmed=True, activity=a2)
gm.save()
m = Member.objects.get(person__userid=userid3, offering=course)
gm = GroupMember(group=g, student=m, confirmed=True, activity=a2)
gm.save()
client = Client()
# login as "0aaa0", member of group : test_group for assignment1 and assgnment2
client.login_user("0aaa0")
#submission page for assignment 1
url = reverse('submission.views.show_components', kwargs={'course_slug': course.slug,'activity_slug':a1.slug})
response = basic_page_tests(self, client, url)
self.assertContains(response, "This is a group submission. You will submit on behalf of the group Test Group.")
self.assertContains(response, "You haven't made a submission for this component.")
def test_staff_page(self):
"""
Check the requires_course_staff_by_slug decorator.
"""
# force the test course's semester to be "current" so the TA still has access
semester = CourseOffering.objects.get(slug=TEST_COURSE_SLUG).semester
today = datetime.date.today()
semester.start = today
semester.end = today + datetime.timedelta(days=90)
semester.save()
# a URL and some members/non-members
url = reverse('offering:class_list',
kwargs={'course_slug': TEST_COURSE_SLUG})
instr = "ggbaker"
ta = Member.objects.filter(offering__slug=TEST_COURSE_SLUG,
role='TA')[0].person.userid
student = "0aaa0"
nobody = "0bbb6"
client = Client()
# try without logging in
response = client.get(url)
self.assertEqual(response.status_code, 302)
# try as instructor
client.login_user(instr)
response = client.get(url)
self.assertEqual(response.status_code, 200)
validate_content(self, response.content, url)
# try as TA.
client.login_user(ta)
response = client.get(url)
self.assertEqual(response.status_code, 200)
# try as student
client.login_user(student)
response = client.get(url)
self.assertEqual(response.status_code, 403)
# try as non-member
client.login_user(nobody)
response = client.get(url)
self.assertEqual(response.status_code, 403)
# try again as TA, but cheat by changing the semester for the course first. We also have to change something
# else, in this case, the section, in order to avoid violating unique constraints when saving it.
c = CourseOffering.objects.get(slug=TEST_COURSE_SLUG)
c.semester = Semester.current()
c.section = 'q100'
c.save()
client.login_user(ta)
response = client.get(url)
self.assertEqual(response.status_code, 200)
def test_grad_status(self):
self.assertEqual(
set(dict(STATUS_CHOICES).keys()) | set([None]),
set(SHORT_STATUSES.keys()))
client = Client()
client.login_user('dzhao')
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(-8)), 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
# The following is no longer true. The latest status (based on start date) is the one that wins, period,
# whether it's manually put in or imported from SIMS.
#
# 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(-3)), 'COMP')
self.assertEqual(gs.status_as_of(this_sem), 'REJE')
self.assertEqual(gs.status_as_of(this_sem.offset(1)), 'REJE')
def test_staff_page(self):
"""
Check the requires_course_staff_by_slug decorator.
"""
# a URL and some members/non-members
url = reverse('grades.views.class_list', kwargs={'course_slug': TEST_COURSE_SLUG})
instr = "ggbaker"
ta = Member.objects.filter(offering__slug=TEST_COURSE_SLUG, role='TA')[0].person.userid
student = "0aaa0"
nobody = "0bbb6"
client = Client()
# try without logging in
response = client.get(url)
self.assertEquals(response.status_code, 302)
# try as instructor
client.login_user(instr)
response = client.get(url)
self.assertEquals(response.status_code, 200)
validate_content(self, response.content, url)
# try as TA
client.login_user(ta)
response = client.get(url)
self.assertEquals(response.status_code, 200)
# try as student
client.login_user(student)
response = client.get(url)
self.assertEquals(response.status_code, 403)
# try as non-member
client.login_user(nobody)
response = client.get(url)
self.assertEquals(response.status_code, 403)
def test_inaccessible_pages(self):
client = Client()
contract_id = 1
url = reverse('sessionals:sessionals_index')
response = client.get(url)
self.assertEqual(response.status_code, 302)
# Now log in but without the correct role
client.login_user('foo')
response = client.get(url)
self.assertEqual(response.status_code, 403)
url = reverse('sessionals:delete_contract', kwargs={'contract_id': contract_id})
response = client.post(url, follow=True)
self.assertEqual(response.status_code, 403)
def test_upload(self):
_, course = create_offering()
a1 = NumericActivity(name="Assignment 1", short_name="A1", status="RLS", offering=course, position=2, max_grade=15, due_date=datetime.datetime.now() + datetime.timedelta(hours=1), group=False)
a1.save()
p = Person.objects.get(userid="ggbaker")
member = Member(person=p, offering=course, role="INST", career="NONS", added_reason="UNK")
member.save()
c = Code.Component(activity=a1, title="Code File", position=3, max_size=2000, allowed=".py")
c.save()
userid1 = "0aaa0"
userid2 = "0aaa1"
userid3 = "0aaa2"
for u in [userid1, userid2,userid3]:
p = Person.objects.get(userid=u)
m = Member(person=p, offering=course, role="STUD", credits=3, career="UGRD", added_reason="UNK")
m.save()
# submit as student
client = Client()
client.login_user("0aaa0")
url = reverse('submission.views.show_components', kwargs={'course_slug': course.slug,'activity_slug':a1.slug})
response = basic_page_tests(self, client, url)
# submit a file
tmpf = tempfile.NamedTemporaryFile(suffix=".py", delete=False)
codecontents = 'print "Hello World!"\n'
tmpf.write(codecontents)
tmpf.close()
try:
fh = open(tmpf.name, "r")
data = {"%i-code" % (c.id): fh}
response = client.post(url, data)
self.assertEquals(response.status_code, 302)
finally:
os.unlink(tmpf.name)
# make sure it's there and correct
subs = StudentSubmission.objects.all()
self.assertEquals(len(subs), 1)
sub = subs[0]
self.assertEquals(sub.member.person.userid, '0aaa0')
codes = SubmittedCode.objects.all()
self.assertEquals(len(codes), 1)
code = codes[0]
code.code.open()
self.assertEquals(code.code.read(), codecontents)
def test_staff_page(self):
"""
Check the requires_course_staff_by_slug decorator.
"""
# a URL and some members/non-members
url = reverse('grades.views.class_list', kwargs={'course_slug': TEST_COURSE_SLUG})
instr = "ggbaker"
ta = Member.objects.filter(offering__slug=TEST_COURSE_SLUG, role='TA')[0].person.userid
student = "0aaa0"
nobody = "0bbb6"
client = Client()
# try without logging in
response = client.get(url)
self.assertEquals(response.status_code, 302)
# try as instructor
client.login_user(instr)
response = client.get(url)
self.assertEquals(response.status_code, 200)
validate_content(self, response.content, url)
# try as TA
client.login_user(ta)
response = client.get(url)
self.assertEquals(response.status_code, 200)
# try as student
client.login_user(student)
response = client.get(url)
self.assertEquals(response.status_code, 403)
# try as non-member
client.login_user(nobody)
response = client.get(url)
self.assertEquals(response.status_code, 403)
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'],
{'course_slug': crs.slug})
test_views(self, c, 'offering:pages:', ['view_page', 'page_history', 'edit_page'],
{'course_slug': crs.slug, 'page_label': 'OtherPage'})
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, '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_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.assertEqual(response.status_code, 200)
def test_front_page(self):
# log in as student in the course
userid = Member.objects.filter(offering__slug=TEST_COURSE_SLUG, role="STUD")[0].person.userid
client = Client()
client.login_user(userid)
response = client.get("/")
self.assertEqual(response.status_code, 200)
# this student is in this course: check for a link to its page (but it only appears after start of semester)
c = CourseOffering.objects.get(slug=TEST_COURSE_SLUG)
if c.semester.start < datetime.date.today():
self.assertContains(response, '<a href="%s"' % (c.get_absolute_url()) )
validate_content(self, response.content, "index page")
def test_front_page(self):
# log in as student in the course
userid = Member.objects.filter(offering__slug=TEST_COURSE_SLUG, role="STUD")[0].person.userid
client = Client()
client.login_user(userid)
response = client.get("/")
self.assertEqual(response.status_code, 200)
# this student is in this course: check for a link to its page (but it only appears after start of semester)
c = CourseOffering.objects.get(slug=TEST_COURSE_SLUG)
if c.semester.start < datetime.date.today():
self.assertContains(response, '<a href="%s"' % (c.get_absolute_url()) )
validate_content(self, response.content, "index page")
def test_ajax(self):
client = Client()
call_command('update_index', 'coredata', verbosity=0) # make sure we have the same data in DB and haystack
# test person autocomplete
client.login_user("dzhao")
p = Person.objects.get(userid='ggbaker')
url = reverse('data:student_search')
response = client.get(url, {'term': 'ggba'})
self.assertEqual(response.status_code, 200)
self.assertEqual(response['content-type'], 'application/json')
# should find this person
data = json.loads(response.content)
emplids = [str(d['value']) for d in data]
self.assertIn(str(p.emplid), emplids)
def test_ajax(self):
client = Client()
call_command('update_index', 'coredata', verbosity=0) # make sure we have the same data in DB and haystack
# test person autocomplete
client.login_user("dzhao")
p = Person.objects.get(userid='ggbaker')
url = reverse('data:student_search')
response = client.get(url, {'term': 'ggba'})
self.assertEqual(response.status_code, 200)
self.assertEqual(response['content-type'], 'application/json')
# should find this person
data = json.loads(response.content.decode('utf8'))
emplids = [str(d['value']) for d in data]
self.assertIn(str(p.emplid), emplids)
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, 'submission.views.', ['add_component'],
{'course_slug': offering.slug, 'activity_slug': activity.slug}, qs='type='+label)
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_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_artifact_notes_success(self):
"""
Check overall pages for the grad module and make sure they all load
"""
client = Client()
client.login_user("dzhao")
for view in ['new_nonstudent', 'new_artifact', 'view_artifacts',
'view_courses', 'view_course_offerings', 'view_all_semesters']:
try:
url = reverse('advisornotes.views.' + view, kwargs={})
response = basic_page_tests(self, client, url)
self.assertEqual(response.status_code, 200)
except:
print "with view==" + repr(view)
raise
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'], {})
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)
