class TestManageSingleGroupMixin(object):
    DELIVERY_TYPES = 'electronic'

    def setUp(self):
        self.testhelper = TestHelper()
        self.testhelper.add(nodes='uni',
                            subjects=['sub'],
                            periods=['p1:begins(-2):ends(6)'],
                            assignments=['a1:admin(a1admin):delivery_types({0})'.format(self.DELIVERY_TYPES)])
        self.assignment = self.testhelper.sub_p1_a1

    def browseToAndSelectAs(self, username, select_group):
        path = '/assignment/{0}/@@manage-students/@@select/{1}'.format(self.assignment.id,
                                                                       select_group.id)
        self.loginTo(username, path)
        return self.waitForAndFindElementByCssSelector('.devilry_subjectadmin_singlegroupview')

    def create_group(self, groupspec):
        self.testhelper.add_to_path('uni;sub.p1.a1.{0}'.format(groupspec))
        groupname = groupspec.split('.')[0].split(':')[0]
        return getattr(self.testhelper, 'sub_p1_a1_{0}'.format(groupname))

    def find_element(self, cssselector):
        return self.selenium.find_element_by_css_selector('.devilry_subjectadmin_singlegroupview {0}'.format(cssselector))
    def find_elements(self, cssselector):
        return self.selenium.find_elements_by_css_selector('.devilry_subjectadmin_singlegroupview {0}'.format(cssselector))

    def find_listofgroups_rows(self, selected_only=False):
        cssselector = '.devilry_subjectadmin_listofgroups .x-grid-row'
        if selected_only:
            cssselector += '-selected'
        return self.selenium.find_elements_by_css_selector(cssselector)
class TestManageMultipleStudentsMixin(object):
    def setUp(self):
        self.testhelper = TestHelper()
        self.testhelper.add(nodes='uni',
                            subjects=['sub'],
                            periods=['p1'],
                            assignments=['a1:admin(a1admin)'])
        self.assignment = self.testhelper.sub_p1_a1

    def browseToAndSelectAs(self, username, select_groups=[]):
        select_ids = ','.join([str(group.id) for group in select_groups])
        path = '/assignment/{0}/@@manage-students/@@select/{1}'.format(self.assignment.id,
                                                                       select_ids)
        self.loginTo(username, path)
        self.waitForCssSelector('.devilry_subjectadmin_multiplegroupsview')

    def create_group(self, groupspec):
        self.testhelper.add_to_path('uni;sub.p1.a1.{0}'.format(groupspec))
        groupname = groupspec.split('.')[0].split(':')[0]
        return getattr(self.testhelper, 'sub_p1_a1_{0}'.format(groupname))

    def find_element(self, cssselector):
        return self.selenium.find_element_by_css_selector('.devilry_subjectadmin_multiplegroupsview {0}'.format(cssselector))

    def find_elements(self, cssselector):
        return self.selenium.find_elements_by_css_selector('.devilry_subjectadmin_multiplegroupsview {0}'.format(cssselector))
class TestRestAssignmentListing(TestCase):
    def setUp(self):
        self.testhelper = TestHelper()
        #self.testhelper.add(nodes='uni:admin(uniadmin)',
                            #subjects=['duck2000:admin(adminone,admintwo):ln(Something fancy)',
                                      #'duck3000',
                                      #'duck1000:admin(adminone)',
                                      #'duck4000:admin(adminone,admintwo,singleadmin)'])
        self.client = RestClient()


    def _get(self, **data):
        return self.client.rest_get(reverse('devilry_examiner-rest-assignmentlisting'), **data)

    def _getas(self, username, **data):
        self.client.login(username=username, password='******')
        return self._get(**data)

    def test_get(self):
        self.testhelper.create_user('examiner1')
        content, response = self._getas('examiner1')
        self.assertEquals(response.status_code, 200)
        self.assertEquals(content, ['Hello', 'world'])

    def test_get_noauth(self):
        content, response = self._get()
        self.assertEquals(response.status_code, 401)
Beispiel #4
0
class TestSubjectListAll(SubjectAdminSeleniumTestCase):
    def setUp(self):
        self.testhelper = TestHelper()
        self.testhelper.create_superuser('grandma')
        self.testhelper.add(nodes='uni:admin(uniadmin)',
                            subjects=['duck1100:admin(duck1100adm)', 'duck1010:ln(DUCK 1010 - Programming)', 'duck9000'])
        self.url = '/allsubjects/'

    def _get_show_subject_url(self, subject):
        return '#/subject/{0}/'.format(subject.id)

    def test_listall(self):
        self.login('uniadmin')
        self.browseTo(self.url)
        self.waitForCssSelector('.devilry_allSubjectsList')
        self.assertTrue('All subjects' in self.selenium.page_source)
        subjectlist = self.selenium.find_element_by_css_selector('.devilry_allSubjectsList')
        self.assertEquals(len(subjectlist.find_elements_by_css_selector('li.devilry_subject')), 3)
        self.assertEquals(len(subjectlist.find_elements_by_css_selector('.devilry_subject_duck1100')), 1)
        self.assertEquals(len(subjectlist.find_elements_by_css_selector('.devilry_subject_duck1010')), 1)
        self.assertEquals(len(subjectlist.find_elements_by_css_selector('.devilry_subject_duck9000')), 1)
        self.assertTrue('DUCK 1010 - Programming' in self.selenium.page_source)
        self.assertTrue(self._get_show_subject_url(self.testhelper.duck1100) in self.selenium.page_source)
        self.assertTrue(self._get_show_subject_url(self.testhelper.duck1010) in self.selenium.page_source)
        self.assertTrue(self._get_show_subject_url(self.testhelper.duck9000) in self.selenium.page_source)

    def test_listall_limited(self):
        self.login('duck1100adm')
        self.browseTo(self.url)
        self.waitForCssSelector('.devilry_allSubjectsList')
        subjectlist = self.selenium.find_element_by_css_selector('.devilry_allSubjectsList')
        self.assertEquals(len(subjectlist.find_elements_by_css_selector('li.devilry_subject')), 1)
class TestLanguageSelect(TestCase):
    def setUp(self):
        self.client = RestClient()

        self.url = '/devilry_i18n/rest/languageselect'
        self.testhelper = TestHelper()
        self.testhelper.create_user('testuser')

    def _getas(self, username):
        self.client.login(username=username, password='******')
        return self.client.rest_get(self.url)

    def _get_languagecode(self, username):
        user = User.objects.get(username=username)
        return user.devilryuserprofile.languagecode

    def _set_languagecode(self, username, languagecode):
        profile = User.objects.get(username=username).devilryuserprofile
        profile.languagecode = languagecode
        profile.save()

    def test_get_languagecode_none(self):
        self.assertEquals(self._get_languagecode('testuser'), None)
        content, response = self._getas('testuser')
        self.assertEquals(response.status_code, 200)
        self.assertEquals(content['preferred'], None)
        self.assertEquals(content['selected']['languagecode'],
                          settings.LANGUAGE_CODE)

    def test_get_languagecode_set(self):
        self._set_languagecode('testuser', 'nb')
        content, response = self._getas('testuser')
        self.assertEquals(response.status_code, 200)
        self.assertEquals(content['preferred'], 'nb')
        self.assertEquals(content['selected']['languagecode'], 'nb')

    def _putas(self, username, data):
        self.client.login(username=username, password='******')
        return self.client.rest_put(self.url, data)

    def test_put(self):
        content, response = self._putas('testuser', {'preferred': 'nb'})
        self.assertEquals(response.status_code, 200)
        self.assertEquals(content['preferred'], 'nb')
        self.assertEquals(self._get_languagecode('testuser'), 'nb')

    def test_put_invalid(self):
        content, response = self._putas('testuser', {'preferred': 'invalid-code'})
        self.assertEquals(response.status_code, 400)
        self.assertEquals(content['field_errors']['preferred'],
                          [u'Invalid languagecode: invalid-code'])

    def test_put_with_extradata(self):
        content, response = self._putas('testuser', {'preferred': 'nb',
                                                     'selected': {'ignored': 'data'},
                                                     'available': ['ignored']})
        self.assertEquals(response.status_code, 200)
        self.assertEquals(content['preferred'], 'nb')
        self.assertEquals(self._get_languagecode('testuser'), 'nb')
Beispiel #6
0
class TestAssignmentDangerous(SubjectAdminSeleniumTestCase, RenameBasenodeTestMixin, DeleteBasenodeTestMixin):
    renamebutton_id = 'assignmentRenameButton'
    deletebutton_id = 'assignmentDeleteButton'

    def setUp(self):
        self.testhelper = TestHelper()
        self.testhelper.add(nodes='uni:admin(uniadmin)',
                            subjects=['sub'],
                            periods=['period1:begins(-2):admin(p1admin)'],
                            assignments=['week1:admin(weekadmin)'])

    def _browseToAssignment(self, id):
        self.browseTo('/assignment/{id}/'.format(id=id))

    def test_rename(self):
        self.login('weekadmin')
        self._browseToAssignment(self.testhelper.sub_period1_week1.id)
        self.waitForCssSelector('.devilry_subjectadmin_assignmentoverview')
        self.rename_test_helper(self.testhelper.sub_period1_week1)

    def test_rename_failure(self):
        self.login('weekadmin')
        self._browseToAssignment(self.testhelper.sub_period1_week1.id)
        self.waitForCssSelector('.devilry_subjectadmin_assignmentoverview')
        self.rename_test_failure_helper()

    def test_delete(self):
        self.testhelper.add(nodes='uni',
                            subjects=['sub'],
                            periods=['period1:begins(-2):admin(p1admin)'],
                            assignments=['willbedeleted'])
        self.login('p1admin')
        self._browseToAssignment(self.testhelper.sub_period1_willbedeleted.id)
        self.waitForCssSelector('.devilry_subjectadmin_assignmentoverview')
        assignmenturl = self.selenium.current_url
        self.perform_delete()
        self.waitFor(self.selenium, lambda s: s.current_url != assignmenturl) # Will time out and fail unless the page is changed after delete
        self.assertEquals(Assignment.objects.filter(id=self.testhelper.sub_period1_willbedeleted.id).count(), 0)

    def test_delete_notparentadmin(self):
        self.testhelper.add(nodes='uni',
                            subjects=['sub'],
                            periods=['period1:begins(-2)'],
                            assignments=['willbedeleted:admin(willbedeletedadm)'])
        self.login('willbedeletedadm')
        self._browseToAssignment(self.testhelper.sub_period1_willbedeleted.id)
        self.waitForCssSelector('.devilry_subjectadmin_assignmentoverview')
        self.click_delete_button()
        self.waitForText('Only superusers can delete non-empty items') # Will time out and fail unless the dialog is shown

    def test_delete_not_empty(self):
        self.testhelper.add_to_path('uni;sub.period1.week1.g1:candidate(goodStud1):examiner(exam1).d1')
        self.testhelper.add_delivery('sub.period1.week1.g1', {'bad.py': ['print ', 'bah']})
        self.login('uniadmin')
        self._browseToAssignment(self.testhelper.sub_period1_week1.id)
        self.waitForCssSelector('.devilry_subjectadmin_assignmentoverview')
        self.click_delete_button()
        self.waitForText('Only superusers can delete non-empty items') # Will time out and fail unless the dialog is shown
Beispiel #7
0
class TestEditPublishingTime(SubjectAdminSeleniumTestCase):
    def setUp(self):
        self.testhelper = TestHelper()
        self.testhelper.add(nodes='uni',
                            subjects=['sub'],
                            periods=['period1:begins(-3)'],
                            assignments=['week1:admin(week1admin)'])
        self.login('week1admin')

        self.browseTo('/assignment/1/')
        self.waitForCssSelector('.devilry_subjectadmin_editpublishingtime_widget .edit_link')
        button = self.selenium.find_element_by_css_selector('.devilry_subjectadmin_editpublishingtime_widget .edit_link')
        button.click()
        self.waitForCssSelector('.devilry_subjectadmin_editpublishingtime')

        editpublishingtime_window = self.selenium.find_element_by_css_selector('.devilry_subjectadmin_editpublishingtime')
        self.datefield = editpublishingtime_window.find_element_by_css_selector('.devilry_extjsextras_datefield input')
        self.timefield = editpublishingtime_window.find_element_by_css_selector('.devilry_extjsextras_timefield input')
        self.savebutton = editpublishingtime_window.find_element_by_css_selector('.devilry_extjsextras_savebutton button')
        self.cancelbutton = editpublishingtime_window.find_element_by_css_selector('.devilry_extjsextras_cancelbutton')
        self.editpublishingtime_window = editpublishingtime_window

    def _set_datetime(self, date, time):
        self.datefield.clear()
        self.timefield.clear()
        self.datefield.send_keys(date)
        self.timefield.send_keys(time)

    def test_editpublishingtime(self):
        self.assertTrue('Publishing time' in self.selenium.page_source)
        self.assertTrue('Choose a time when time when students will be able to start adding deliveries on the assignment' in self.selenium.page_source)
        now = datetime.now()
        yesterday = now - timedelta(days=1)
        isoday_yesterday = yesterday.date().isoformat()
        self._set_datetime(isoday_yesterday, '12:00')
        self.savebutton.click()
        self.waitForText('{isoday_yesterday} 12:00'.format(**vars())) # If this times out, it has not been updated
        week1 = Assignment.objects.get(pk=self.testhelper.sub_period1_week1.pk)
        self.assertEquals(week1.publishing_time.date(), yesterday.date())

    def test_editpublishingtime_notpublished(self):
        tomorrow = datetime.now() + timedelta(days=1)
        isoday_tomorrow = tomorrow.date().isoformat()
        self._set_datetime(isoday_tomorrow, '12:00')
        self.savebutton.click()
        self.waitForText('{isoday_tomorrow} 12:00'.format(**vars())) # If this times out, it has not been updated
        week1 = Assignment.objects.get(pk=self.testhelper.sub_period1_week1.pk)
        self.assertEquals(week1.publishing_time.date(), tomorrow.date())

    def test_cancel(self):
        self.failIfCssSelectorFound(self.editpublishingtime_window, '.x-tool-close')  # Make sure window does not have closable set to true
        self.cancelbutton.click()
        self.assertFalse('.devilry_subjectadmin_editpublishingtime' in self.selenium.page_source)

    def test_editpublishingtime_errorhandling(self):
        self._set_datetime('2000-02-01', '12:00')
        self.savebutton.click()
        self.waitForText("The publishing time, 2000-02-01 12:00:00, is invalid")
class TestEditPublishingTime(SubjectAdminSeleniumTestCase):
    def setUp(self):
        self.testhelper = TestHelper()
        self.testhelper.add(nodes='uni',
                            subjects=['sub'],
                            periods=['period1:begins(-3)'],
                            assignments=['week1:admin(week1admin)'])
        self.week1 = self.testhelper.sub_period1_week1
        self.loginTo('week1admin', '/assignment/{id}/'.format(id=self.week1.id))

        self.readOnlyPanel = self.waitForAndFindElementByCssSelector('.devilry_subjectadmin_editpublishingtime_widget .markupmoreinfobox')
        button = self.waitForAndFindElementByCssSelector('.devilry_subjectadmin_editpublishingtime_widget .edit_link')
        button.click()

        panel = self.waitForAndFindElementByCssSelector('.devilry_subjectadmin_editpublishingtimepanel')
        self.datefield = panel.find_element_by_css_selector('.devilry_extjsextras_datefield input')
        self.timefield = panel.find_element_by_css_selector('.devilry_extjsextras_timefield input')
        self.savebutton = panel.find_element_by_css_selector('.okbutton button')
        self.cancelbutton = panel.find_element_by_css_selector('.cancelbutton button')

    def _set_datetime(self, date, time):
        self.datefield.clear()
        self.timefield.clear()
        self.datefield.send_keys(date)
        self.timefield.send_keys(time)

    def test_editpublishingtime(self):
        self.assertTrue('Publishing time' in self.selenium.page_source)
        self.assertTrue('Choose a time when students will be able to start adding deliveries on the assignment' in self.selenium.page_source)
        now = datetime.now()
        yesterday = now - timedelta(days=1)
        isoday_yesterday = yesterday.date().isoformat()
        self._set_datetime(isoday_yesterday, '12:00')
        self.savebutton.click()
        self.waitForText('{isoday_yesterday} 12:00'.format(**vars())) # If this times out, it has not been updated
        week1 = Assignment.objects.get(pk=self.testhelper.sub_period1_week1.pk)
        self.assertEquals(week1.publishing_time.date(), yesterday.date())

    def test_editpublishingtime_notpublished(self):
        tomorrow = datetime.now() + timedelta(days=1)
        isoday_tomorrow = tomorrow.date().isoformat()
        self._set_datetime(isoday_tomorrow, '12:00')
        self.savebutton.click()
        self.waitForText('{isoday_tomorrow} 12:00'.format(**vars())) # If this times out, it has not been updated
        week1 = Assignment.objects.get(pk=self.testhelper.sub_period1_week1.pk)
        self.assertEquals(week1.publishing_time.date(), tomorrow.date())

    def test_cancel(self):
        self.cancelbutton.click()
        self.waitForDisplayed(self.readOnlyPanel)

    def test_editpublishingtime_errorhandling(self):
        self._set_datetime('2000-02-01', '12:00')
        self.savebutton.click()
        self.waitForText("The publishing time, 2000-02-01 12:00:00, is invalid")
Beispiel #9
0
    def setUp(self):
        self.testhelper = TestHelper()

        self.testhelper.add(nodes="uni",
            subjects=["sub"],
            periods=["p1:begins(-24):ends(6)"],
            assignments=['a1:pub(1)', 'a3:pub(4)', 'a2:pub(3)'],
            assignmentgroups=["stud1:candidate(student1):examiner(examiner1)",
                              "stud2:candidate(student2):examiner(examiner1)",
                              "stud3:candidate(student3):examiner(examiner1)",
                              "stud4:candidate(student4,student3):examiner(examiner1)"],
            deadlines=['d1:ends(1)'])
class TestRestAggregatedStudentInfo(TestCase):
    def setUp(self):
        self.testhelper = TestHelper()
        self.client = RestClient()
        self.testhelper.add(nodes='uni:admin(uniadmin)',
                            subjects=['sub'],
                            periods=['p1:begins(-1)'],
                            assignments=['a1'])
        self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1,student2):examiner(examiner1).d1:ends(5)')
        self.group = self.testhelper.sub_p1_a1_g1


    def _get(self, user_id):
        return self.client.rest_get(reverse('devilry_nodeadmin-aggregatedstudentinfo', kwargs={'user_id': user_id}))

    def _getas(self, username, id):
        self.client.login(username=username, password='******')
        return self._get(id)

    def test_get(self):
        content, response = self._getas('uniadmin', self.testhelper.student1.id)
        self.assertEquals(response.status_code, 200)

        user = {u'username': u'student1', 
                u'displayname': u'student1', 
                u'id': 2, u'full_name': None, 
                u'email': u'*****@*****.**'} 
        self.assertEquals(content['user'], user)

        grouped_by_hierarky = content['grouped_by_hierarky'][0]
        self.assertEquals(set(grouped_by_hierarky.keys()), set([u'long_name', u'id', u'short_name', u'periods']))

        period = grouped_by_hierarky['periods'][0]
        self.assertEquals(set(period.keys()), set([u'short_name', u'assignments', 
                                          u'is_relatedstudent', u'start_time', 
                                          u'is_active', u'qualified_forexams', 
                                          u'long_name', u'end_time', u'id']))



        assignments = period['assignments'][0]
        self.assertEquals(set(period.keys()), set([u'short_name', u'assignments', 
                                                   u'is_relatedstudent', u'start_time', 
                                                   u'is_active', u'qualified_forexams', 
                                                   u'long_name', u'end_time', u'id']))

        groups = assignments['groups'][0]
        self.assertEquals(set(groups.keys()), set([u'status', u'active_feedback', u'id']))

    def test_get_noauth(self):
        content, response = self._get(self.testhelper.student1.id)
        self.assertEquals(response.status_code, 401)
class TestNodeAdminRequired(TestCase):
    def setUp(self):
        self.testhelper = TestHelper()
        self.testhelper.add(nodes="tstnode.subnode:admin(normaluser)")
        self.testhelper.create_superuser("superuser")

    def test_nodeadmin_required_superuser(self):
        nodeadmin_required(self.testhelper.superuser, "", None ) # Calls is_superuser and exits without further checks

    def test_nodeadmin_required_normaluser(self):
        nodeadmin_required(self.testhelper.normaluser, "", self.testhelper.tstnode_subnode.id)

    def test_nodeadmin_required_normaluser_denied(self):
        self.assertRaises(PermissionDeniedError, nodeadmin_required, self.testhelper.normaluser, "", self.testhelper.tstnode.id)
Beispiel #12
0
class TestSubjectEditAdministrators(SubjectAdminSeleniumTestCase,
                                    EditAdministratorsTestMixin,
                                    SubjectTestCommonMixin):

    def setUp(self):
        self.testhelper = TestHelper()
        self.testhelper.add(nodes='uni:admin(uniadmin)',
                            subjects=['duck1100'])
        self.login('uniadmin')

    def getBasenode(self):
        return self.testhelper.duck1100

    def browseToTestBasenode(self):
        self.browseToSubject(self.testhelper.duck1100.id)
Beispiel #13
0
class TestPeriodEditAdministrators(SubjectAdminSeleniumTestCase, PeriodTestCommonMixin,
                                   EditAdministratorsTestMixin):

    def setUp(self):
        self.testhelper = TestHelper()
        self.testhelper.add(nodes='uni:admin(uniadmin)',
                            subjects=['sub'],
                            periods=['p1'])
        self.login('uniadmin')

    def getBasenode(self):
        return self.testhelper.sub_p1

    def browseToTestBasenode(self):
        self.browseToPeriod(self.getBasenode().id)
 def setUp(self):
     self.testhelper = TestHelper()
     self.testhelper.add(nodes='uni',
                         subjects=['sub'],
                         periods=['p1:admin(p1admin)', 'p2'])
     self.client = RestClient()
     self.url = '/devilry_subjectadmin/rest/createnewassignment/'
 def setUp(self):
     self.testhelper = TestHelper()
     self.testhelper.add(nodes='uni:admin(uniadmin)',
         subjects=['sub'],
         periods=['p1:admin(periodadmin):begins(-3):ends(6)'])
     self.client = RestClient()
     self.testhelper.create_superuser('superuser')
    def handle(self, *args, **options):
        from devilry.apps.core.testhelper import TestHelper
        verbosity = get_verbosity(options)
        self.no_groups = options['no_groups']
        setup_logging(verbosity)

        # NOTE: Not running flush - it messes up migrations
        #logging.info('Running manage.py flush')
        #management.call_command('flush', verbosity=0, interactive=False)

        self.testhelper = TestHelper()
#        from django.db import transaction
#        with transaction.commit_on_success():
        self.testhelper.create_superuser('grandma')
        self.testhelper.grandma.is_staff = True
        self.testhelper.grandma.save()
        logging.info('Creating users')
        self.create_users(bad_students)
        self.create_users(medium_students)
        self.create_users(good_students)
        self.create_users([('donald', 'Donald Duck'),
                           ('daisy', 'Daisy Duck'),
                           ('clarabelle', 'Clarabelle Duck'),
                           ('scrooge', 'Scrooge McDuck'),
                           ('della', 'Duck'),
                           ('gladstone', 'Gladstone Gander'),
                           ('fethry', 'Fethry Duck')])
        self._distributeStudentToExaminers()
        logging.info('Generating data (nodes, periods, subjects, deliveries...). Run with -v3 for more details.')
        self.create_duck1010()
        self.create_duck2500p()
        self.create_duck4000()
        self.create_duck6000()
        self.create_duck1100()
        self._unset_groupnames()
Beispiel #17
0
 def setUp(self):
     self.client = Client()
     self.testhelper = TestHelper()
     self.nobody = self.testhelper.create_user('nobody')
     self.superuser = self.testhelper.create_superuser('superuser')
     self.url = reverse('send_email_to_students_email_sending_debug',
                        kwargs={'username': '******'})
 def setUp(self):
     self.testhelper = TestHelper()
     self.testhelper.add(nodes='uni',
                         subjects=['sub'],
                         periods=['p1'],
                         assignments=['a1:admin(a1admin)'])
     self.assignment = self.testhelper.sub_p1_a1
 def setUp(self):
     self.testhelper = TestHelper()
     self.testhelper.add(nodes='uni',
                         subjects=['sub'],
                         periods=['p1:begins(-2):ends(6)'],
                         assignments=['a1:admin(a1admin):delivery_types({0})'.format(self.DELIVERY_TYPES)])
     self.assignment = self.testhelper.sub_p1_a1
Beispiel #20
0
    def handle(self, *args, **options):
        verbosity = get_verbosity(options)
        setup_logging(verbosity)
        logging.info("Running manage.py flush")
        management.call_command("flush", verbosity=0, interactive=False)

        self.testhelper = TestHelper()
        #        from django.db import transaction
        #        with transaction.commit_on_success():
        self.testhelper.create_superuser("grandma")
        self.testhelper.grandma.is_staff = True
        self.testhelper.grandma.save()
        logging.info("Creating users")
        self.create_users(bad_students)
        self.create_users(medium_students)
        self.create_users(good_students)
        self.create_users(
            [
                ("donald", "Donald Duck"),
                ("daisy", "Daisy Duck"),
                ("clarabelle", "Clarabelle Duck"),
                ("scrooge", "Scrooge McDuck"),
                ("della", "Duck"),
                ("gladstone", "Gladstone Gander"),
                ("fethry", "Fethry Duck"),
            ]
        )
        self._distributeStudentToExaminers()
        logging.info("Generating data (nodes, periods, subjects, deliveries...). Run with -v3 for more details.")
        self.create_duck2500p()
        self.create_duck4000()
        self.create_duck6000()
        self.create_duck1100()
        self.create_duck1010()
        self._unset_groupnames()
 def setUp(self):
     self.testhelper = TestHelper()
     self.testhelper.add(nodes='uni:admin(uniadmin)',
                         subjects=['sub'],
                         periods=['p1:admin(p1admin)',
                                  'p2:admin(p2admin)'])
     self.client = RestClient()
 def setUp(self):
     self.testhelper = TestHelper()
     self.testhelper.add(nodes='uni',
                         subjects=['sub'],
                         periods=['period1'],
                         assignments=['week2:admin(week2admin)'])
     self.assignmentid = self.testhelper.sub_period1_week2.id
Beispiel #23
0
    def handle(self, *args, **options):
        verbosity = get_verbosity(options)
        setup_logging(verbosity)
        logging.info('Running manage.py flush')
        management.call_command('flush', verbosity=0, interactive=False)

        self.testhelper = TestHelper()
        self.testhelper.create_superuser('grandma')
        self.testhelper.grandma.is_staff = True
        self.testhelper.grandma.save()
        logging.info('Creating users')
        self.create_users(bad_students)
        self.create_users(medium_students)
        self.create_users(good_students)
        self.create_users([('donald', 'Donald Duck'),
                           ('daisy', 'Daisy Duck'),
                           ('clarabelle', 'Clarabelle Duck'),
                           ('scrooge', 'Scrooge McDuck'),
                           ('della', 'Duck'),
                           ('gladstone', 'Gladstone Gander'),
                           ('fethry', 'Fethry Duck')])
        self._distributeStudentToExaminers()
        logging.info('Generating data (nodes, periods, subjects, deliveries...). Run with -v3 for more details.')
        self.create_duck4000()
        self.create_duck6000()
        self.create_duck1100()
        self.create_duck1010()
 def setUp(self):
     self.client = RestClient()
     self.testhelper = TestHelper()
     self.testhelper.add(
         nodes="uni", subjects=["sub"], periods=["p1:begins(-2)"], assignments=["a1:admin(a1admin)"]  # 2 months ago
     )
     self.assignment = self.testhelper.sub_p1_a1
     self.url = "/devilry_subjectadmin/rest/mergeintogroup/{0}".format(self.assignment.id)
Beispiel #25
0
 def setUp(self):
     self.testhelper = TestHelper()
     self.testhelper.add(nodes='uni',
                         subjects=['sub'],
                         periods=['p1:begins(-2)'], # 2 months ago
                         assignments=['a1:admin(adm):pub(0)']) # 0 days after period begins
     self.client = RestClient()
     self.url = '/devilry_subjectadmin/rest/deadlinesbulk/{0}/'.format(self.testhelper.sub_p1_a1.id)
 def setUp(self):
     self.testhelper = TestHelper()
     self.testhelper.add(nodes='uni:admin(uniadmin)',
                         subjects=['duck2000:admin(duck2000admin)'],
                         periods=['periodone:admin(oneadmin)',
                                  'periodtwo',
                                  'periodthree:admin(adminone)'])
     self.client = RestClient()
 def setUp(self):
     self.testhelper = TestHelper()
     self.testhelper.add(nodes='uni',
                         subjects=['sub:admin(subadmin)'],
                         periods=['p1:admin(p1admin):begins(-2)'],
                         assignments=['a1:admin(a1admin):pub(1)'])
     self.period = self.testhelper.sub_p1
     self.assignment = self.testhelper.sub_p1_a1
 def setUp(self):
     self.testhelper = TestHelper()
     #self.testhelper.add(nodes='uni:admin(uniadmin)',
                         #subjects=['duck2000:admin(adminone,admintwo):ln(Something fancy)',
                                   #'duck3000',
                                   #'duck1000:admin(adminone)',
                                   #'duck4000:admin(adminone,admintwo,singleadmin)'])
     self.client = RestClient()
class TestEditDeadlineHandling(SubjectAdminSeleniumTestCase):
    def setUp(self):
        self.testhelper = TestHelper()
        self.testhelper.add(nodes='uni',
                            subjects=['sub'],
                            periods=['period1:begins(-3)'],
                            assignments=['week1:admin(week1admin)'])
        self.week1 = self.testhelper.sub_period1_week1
        self.loginTo('week1admin', '/assignment/{id}/'.format(id=self.week1.id))

        self.readOnlyPanel = self.waitForAndFindElementByCssSelector('.devilry_subjectadmin_editdeadline_handling_widget .containerwithedittitle')

    def _click_edit(self):
        button = self.waitForAndFindElementByCssSelector('.devilry_subjectadmin_editdeadline_handling_widget .containerwithedittitle .edit_link')
        button.click()

        editdeadline_handlingpanel = self.waitForAndFindElementByCssSelector('.devilry_subjectadmin_editdeadline_handlingpanel')
        self.waitForDisplayed(editdeadline_handlingpanel)
        self.deadline_handlingcheckbox = editdeadline_handlingpanel.find_element_by_css_selector('input.x-form-checkbox')
        self.savebutton = editdeadline_handlingpanel.find_element_by_css_selector('.okbutton button')
        self.cancelbutton = editdeadline_handlingpanel.find_element_by_css_selector('.cancelbutton button')

    def test_readonlypanel(self):
        self.assertEquals(Assignment.objects.get(pk=self.week1.pk).deadline_handling, ELECTRONIC)
        self.waitFor(self.readOnlyPanel, lambda p: 'Soft deadlines' in p.text)

    def test_editdeadline_handling(self):
        self._click_edit()
        self.assertFalse(Assignment.objects.get(pk=self.week1.pk).deadline_handling)
        self.deadline_handlingcheckbox.click()
        self.savebutton.click()
        self.waitFor(self.readOnlyPanel, lambda p: 'Hard deadlines' in p.text)
        self.assertEquals(Assignment.objects.get(pk=self.week1.pk).deadline_handling, NON_ELECTRONIC)

    def test_cancel(self):
        self._click_edit()
        self.cancelbutton.click()
        self.waitForDisplayed(self.readOnlyPanel)

    def test_editdeadline_handling_nochange(self):
        self._click_edit()
        self.assertEquals(Assignment.objects.get(pk=self.week1.pk).deadline_handling, ELECTRONIC)
        self.savebutton.click()
        self.waitForDisplayed(self.readOnlyPanel)
        self.waitForText('Soft deadlines') # If this times out, it has been updated
        self.assertEquals(Assignment.objects.get(pk=self.week1.pk).deadline_handling, ELECTRONIC)
Beispiel #30
0
 def setUp(self):
     self.testhelper = TestHelper()
     self.testhelper.create_user('student1')
     self.testhelper.add(nodes='uni',
                         subjects=['sub'],
                         periods=['p1:begins(-3):ends(10)'],
                         assignments=['a1:pub(1):ln(Assignment One)'])
     self.fileinfo = {'ok.py': ['print ', 'meh']}
Beispiel #31
0
 def setUp(self):
     self.testhelper = TestHelper()
     self.testhelper.create_user('student1')
     self.testhelper.add(nodes='uni',
                         subjects=['sub'],
                         periods=['p1:begins(-3):ends(10)'],
                         assignments=['a1:pub(1):ln(Assignment One)'])
     self.tstfile1 = join(this_dir, 'upload_testfile1.txt')
    def handle(self, *args, **options):
        management.call_command('flush', verbosity=0, interactive=False)
        management.call_command('loaddata', 'dev_grandma', verbosity=0, interactive=False)
        #management.call_command('loaddata', 'dev_duckburghusers', verbosity=0, interactive=False)

        testhelper = TestHelper()
        testhelper.add(nodes="uio:admin(uioadmin).ifi:admin(ifiadmin)",
                 subjects=["inf1100"],
                 periods=["old:begins(-2):ends(1)", "looong"],
                 assignments=["assignment1", "assignment2"],
                 assignmentgroups=["g1:candidate(student1):examiner(examiner1)", "g2:examiner(examiner2)",
                                   "g3:candidate(student2,student3):examiner(examiner1,examiner2)"])
        testhelper.add_to_path('uio.ifi;inf1100.looong.assignment3.group1:examiner(examiner1)')
        testhelper.add_to_path('uio.ifi;inf1100.old.oldassignment.group1:examiner(examiner3)')
Beispiel #33
0
class GroupsGroupedByRelatedStudentAndAssignmentTest(TestCase):
    def setUp(self):
        self.testhelper = TestHelper()

        self.testhelper.add(nodes="uni",
            subjects=["sub"],
            periods=["p1:begins(-24):ends(6)"],
            assignments=['a1:pub(1)', 'a3:pub(4)', 'a2:pub(3)'],
            assignmentgroups=["stud1:candidate(student1):examiner(examiner1)",
                              "stud2:candidate(student2):examiner(examiner1)",
                              "stud3:candidate(student3):examiner(examiner1)",
                              "stud4:candidate(student4,student3):examiner(examiner1)"],
            deadlines=['d1:ends(1)'])

    def _add_good_feedback(self, group):
        delivery = self.testhelper.add_delivery(group, {"good.py": "print awesome"})
        self.testhelper.add_feedback(delivery, {'grade': '100/100', 'points': 100, 'is_passing_grade': True})

    def _add_bad_feedback(self, group):
        delivery = self.testhelper.add_delivery(group, {"bad.py": "print bad"})
        self.testhelper.add_feedback(delivery, {'grade': '0/100', 'points': 0, 'is_passing_grade': False})


    def test_iter_assignments(self):
        grouper = GroupsGroupedByRelatedStudentAndAssignment(self.testhelper.sub_p1)
        shortnames = [assignment.short_name for assignment in grouper.iter_assignments()]
        self.assertEquals(shortnames, ['a1', 'a2', 'a3'])

    def test_iter_students_that_is_candidate_but_not_in_related_none(self):
        grouper = GroupsGroupedByRelatedStudentAndAssignment(self.testhelper.sub_p1)
        self.assertEqual(len(list(grouper.iter_relatedstudents_with_results())), 0)

    def test_iter_students_that_is_candidate_but_not_in_related(self):
        grouper = GroupsGroupedByRelatedStudentAndAssignment(self.testhelper.sub_p1)
        ignored = list(grouper.iter_students_that_is_candidate_but_not_in_related())
        self.assertEquals(len(ignored), 4)
        student1_info = None
        for aggregated_relstudentinfo in ignored:
            if aggregated_relstudentinfo.user == self.testhelper.student1:
                student1_info = aggregated_relstudentinfo
                break
        grouplists = list(student1_info.iter_groups_by_assignment())
        self.assertEquals(len(grouplists), 3) # Should match the number of assignments
        self.assertEquals(len(grouplists[0]), 1)
        self.assertEquals(grouplists[0][0].feedback, None)

    def test_iter_students_with_feedback_that_is_candidate_but_not_in_related_none(self):
        grouper = GroupsGroupedByRelatedStudentAndAssignment(self.testhelper.sub_p1)
        self.assertEquals(len(list(grouper.iter_students_with_feedback_that_is_candidate_but_not_in_related())), 0)
        self.assertEquals(len(list(grouper.iter_relatedstudents_with_results())), 0)

    def test_iter_students_with_feedback_that_is_candidate_but_not_in_related(self):
        self._add_bad_feedback(self.testhelper.sub_p1_a1_stud1)
        grouper = GroupsGroupedByRelatedStudentAndAssignment(self.testhelper.sub_p1)
        ignored = list(grouper.iter_students_with_feedback_that_is_candidate_but_not_in_related())
        self.assertEquals(len(ignored), 1)
        grouplists = list(ignored[0].iter_groups_by_assignment())
        self.assertEquals(len(grouplists), 3) # Should match the number of assignments
        self.assertEquals(grouplists[0][0].feedback.grade, '0/100')

    def test_iter_relatedstudents_with_results(self):
        self._add_bad_feedback(self.testhelper.sub_p1_a1_stud1)
        self.testhelper.sub_p1.relatedstudent_set.create(user=self.testhelper.student1)
        grouper = GroupsGroupedByRelatedStudentAndAssignment(self.testhelper.sub_p1)
        results = list(grouper.iter_relatedstudents_with_results())
        self.assertEqual(len(results), 1)
        student1info = results[0]
        grouplists = list(student1info.iter_groups_by_assignment())
        self.assertEqual(len(grouplists), 3)  # Should match the number of assignments
        self.assertEqual(grouplists[0].get_best_gradestring(), '0/100')

    def test_iter_relatedstudents_with_results_multi(self):
        self.testhelper.sub_p1.relatedstudent_set.create(user=self.testhelper.student1)
        self.testhelper.sub_p1.relatedstudent_set.create(user=self.testhelper.student2)
        grouper = GroupsGroupedByRelatedStudentAndAssignment(self.testhelper.sub_p1)
        results = list(grouper.iter_relatedstudents_with_results())
        self.assertEqual(len(results), 2)
Beispiel #34
0
def create_testgroups(period, assignments, **shared_kwargs):
    logging.info(str(period))
    for kwargs in assignments:
        kw = dict()
        kw.update(shared_kwargs)
        kw.update(kwargs)
        create_example_assignment(period, **kw)


def add_extra_relatedusers(period):
    for username in ('huey', 'dewey', 'louie', 'april', 'may', 'june'):
        models.RelatedStudent.objects.create(user=User.objects.get(username=username), period=period)


testhelper = TestHelper()
testhelper.add()
testhelper.add(nodes='duckburgh.univ:admin(duckburghboss)',
               subjects=['duck1100:admin(donald):ln(DUCK1100 - Getting started with python)',
                         'duck1080:admin(daisy):ln(DUCK1080 - Making the illogical seem logical)',
                         'duck3580:admin(clarabelle):ln(DUCK3580 - Making the web work)',
                         'duck5063:admin(scrooge):ln(DUCK5063 - Make low level stuff - avoiding permanent psychological scarring of most of the students)'],
               periods=['spring01:admin(fethry,gus,gladstone):ln(Spring year zero)'])

if args.duckburghusers:
    add_extra_relatedusers(testhelper.duck1100_spring01)

# Duck 1100
create_testgroups(testhelper.duck1100_spring01,
                  num_students = args.num_students, num_examiners = args.num_examiners,
                  deliverycountrange=args.deliverycountrange,