示例#1
0
    def test_get_evaluations_by_section(self):
        with self.settings(RESTCLIENTS_SWS_DAO_CLASS=FDAO_SWS,
                           RESTCLIENTS_PWS_DAO_CLASS=FDAO_PWS,
                           RESTCLIENTS_IASYSTEM_DAO_CLASS=FDAO_IAS):

            regid = "9136CCB8F66711D5BE060004AC494FFE"
            term = Term()
            term.year = 2013
            term.quarter = "summer"
            section = Section()
            section.summer_term = "A-term"
            section.term = term
            schedule = _get_schedule(regid, term)
            evals = None
            for section in schedule.sections:
                if section.curriculum_abbr == 'ELCBUS':
                    evals = _get_evaluations_by_section_and_student(
                        section, 1443336)
                    break
            self.assertIsNotNone(evals)
            self.assertEqual(evals[0].section_sln, 13833)
            self.assertEqual(
                evals[0].eval_open_date,
                datetime.datetime(2013, 7, 02, 14, 0, tzinfo=pytz.utc))
            self.assertEqual(
示例#2
0
    def test_filter_schedule_sections_by_summer_term(self):
        with self.settings(RESTCLIENTS_SWS_DAO_CLASS=FDAO_SWS,
                           RESTCLIENTS_PWS_DAO_CLASS=FDAO_PWS):
            regid = "9136CCB8F66711D5BE060004AC494FFE"
            term = Term()
            term.year = 2013
            term.quarter = "summer"
            schedule = _get_schedule(regid, term)
            # ensure it has both A and B terms
            has_a_term = False
            has_b_term = False
            for section in schedule.sections:
                if section.summer_term == "A-term":
                    has_a_term = True
                if section.summer_term == "B-term":
                    has_b_term = True
            self.assertTrue(has_a_term)
            self.assertTrue(has_b_term)

            filter_schedule_sections_by_summer_term(schedule, "A-term")
            # the B-term section no longer exists
            filtered_has_b_term = False
            filtered_has_a_term = False
            filtered_has_full_term = False
            for section in schedule.sections:
                if section.summer_term == "A-term":
                    filtered_has_a_term = True
                if section.summer_term == "B-term":
                    filtered_has_b_term = True
                if section.summer_term == "Full-term":
                    filtered_has_full_term = True

            self.assertFalse(filtered_has_b_term)
            self.assertTrue(filtered_has_full_term)
            self.assertTrue(filtered_has_a_term)
示例#3
0
    def test_summer_term_overlaped(self):
        with self.settings(RESTCLIENTS_SWS_DAO_CLASS=FDAO_SWS):
            term = Term()
            term.year = 2013
            term.quarter = "summer"
            section = Section()
            section.summer_term = "A-term"
            section.term = term

            now_request = RequestFactory().get("/")
            now_request.session = {}
            now_request.session["myuw_override_date"] = "2013-07-10"
            self.assertTrue(summer_term_overlaped(now_request, section))
            section.summer_term = "Full-term"
            self.assertFalse(summer_term_overlaped(now_request, section))
            now_request = RequestFactory().get("/")
            now_request.session = {}
            now_request.session["myuw_override_date"] = "2013-08-10"
            self.assertTrue(summer_term_overlaped(now_request, section))

            section.summer_term = "B-term"
            self.assertTrue(summer_term_overlaped(now_request, section))

            now_request = RequestFactory().get("/")
            now_request.session = {}
            now_request.session["myuw_override_date"] = "2013-03-10"
            self.assertTrue(summer_term_overlaped(now_request, 'None'))
            self.assertTrue(summer_term_overlaped(now_request, '-'))
示例#4
0
文件: library.py 项目: vegitron/myuw
    def test_get_subject_guide_tacoma(self):
        with self.settings(RESTCLIENTS_SWS_DAO_CLASS=FDAO_SWS,
                           RESTCLIENTS_PWS_DAO_CLASS=FDAO_PWS):
            regid = "12345678901234567890123456789012"
            term = Term()
            term.year = 2013
            term.quarter = "spring"
            schedule = _get_schedule(regid, term)
            for section in schedule.sections:
                # 404, general guide link
                if section.curriculum_abbr == 'ROLING' and\
                        section.course_number == '310':
                    self.assertEquals(
                        get_subject_guide_by_section(section),
                        "http://guides.lib.uw.edu/tacoma")

                if section.curriculum_abbr == 'T ARTS' and\
                        section.course_number == '110':
                    self.assertEquals(
                        get_subject_guide_by_section(section),
                        "http://guides.lib.uw.edu/tacoma")

                # has subject guide link
                if section.curriculum_abbr == 'ARCTIC' and\
                        section.course_number == '200':
                    self.assertEquals(
                        get_subject_guide_by_section(section),
                        "http://guides.lib.uw.edu/tacoma/art")
示例#5
0
    def test_multiple_instructors(self):
        with self.settings(RESTCLIENTS_SWS_DAO_CLASS=FDAO_SWS,
                           RESTCLIENTS_PWS_DAO_CLASS=FDAO_PWS,
                           RESTCLIENTS_IASYSTEM_DAO_CLASS=FDAO_IAS):

            regid = "9136CCB8F66711D5BE060004AC494FFE"
            term = Term()
            term.year = 2013
            term.quarter = "summer"
            schedule = _get_schedule(regid, term)
            evals = None
            for section in schedule.sections:
                if section.curriculum_abbr == 'TRAIN' and\
                        section.course_number == '102' and\
                        section.section_id == 'A':
                    evals = _get_evaluations_by_section_and_student(
                        section, 1033334)
                    break
            self.assertIsNotNone(evals)
            self.assertEqual(len(evals), 1)
            self.assertEqual(evals[0].section_sln, 13833)
            self.assertEqual(
                evals[0].eval_open_date,
                datetime.datetime(2013, 8, 23, 14, 0, 0, tzinfo=pytz.utc))
            self.assertEqual(
                evals[0].eval_close_date,
                datetime.datetime(2013, 8, 29, 6, 59, 59, tzinfo=pytz.utc))

            self.assertEqual(len(evals[0].instructor_ids), 3)
            self.assertEqual(evals[0].instructor_ids[0], 123456781)
            self.assertEqual(evals[0].instructor_ids[1], 123456782)
            self.assertEqual(evals[0].instructor_ids[2], 123456798)
示例#6
0
    def test_get_subject_guide_tacoma(self):
        with self.settings(RESTCLIENTS_SWS_DAO_CLASS=FDAO_SWS,
                           RESTCLIENTS_PWS_DAO_CLASS=FDAO_PWS):
            regid = "12345678901234567890123456789012"
            term = Term()
            term.year = 2013
            term.quarter = "spring"
            schedule = _get_schedule(regid, term)
            for section in schedule.sections:
                # 404, general guide link
                if section.curriculum_abbr == 'ROLING' and\
                        section.course_number == '310':
                    self.assertEquals(get_subject_guide_by_section(section),
                                      "http://guides.lib.uw.edu/tacoma")

                if section.curriculum_abbr == 'T ARTS' and\
                        section.course_number == '110':
                    self.assertEquals(get_subject_guide_by_section(section),
                                      "http://guides.lib.uw.edu/tacoma")

                # has subject guide link
                if section.curriculum_abbr == 'ARCTIC' and\
                        section.course_number == '200':
                    self.assertEquals(get_subject_guide_by_section(section),
                                      "http://guides.lib.uw.edu/tacoma/art")
示例#7
0
文件: library.py 项目: vegitron/myuw
    def test_get_subject_guide_seattle(self):
        with self.settings(RESTCLIENTS_SWS_DAO_CLASS=FDAO_SWS):
            regid = "9136CCB8F66711D5BE060004AC494FFE"
            term = Term()
            term.year = 2013
            term.quarter = "spring"
            schedule = _get_schedule(regid, term)
            for section in schedule.sections:
                # 404, general guide link
                if section.curriculum_abbr == 'TRAIN' and\
                        section.course_number == '101':
                    self.assertEquals(
                        get_subject_guide_by_section(section),
                        "http://guides.lib.uw.edu/research")

                # has subject guide link
                if section.curriculum_abbr == 'TRAIN' and\
                        section.course_number == '100':
                    self.assertEquals(
                        get_subject_guide_by_section(section),
                        "http://guides.lib.uw.edu/friendly.php?s=research/pnw")

                # has subject guide link
                if section.curriculum_abbr == 'PHYS' and\
                        section.course_number == '121':
                    self.assertEquals(
                        get_subject_guide_by_section(section),
                        "%s?%s" % ("http://guides.lib.uw.edu/friendly.php",
                                   "s=research/physics_astronomy"))
示例#8
0
    def test_multiple_instructor(self):
        with self.settings(
            RESTCLIENTS_SWS_DAO_CLASS=FDAO_SWS,
            RESTCLIENTS_PWS_DAO_CLASS=FDAO_PWS,
            RESTCLIENTS_IASYSTEM_DAO_CLASS=FDAO_IAS,
        ):

            regid = "9136CCB8F66711D5BE060004AC494FFE"
            term = Term()
            term.year = 2013
            term.quarter = "summer"
            schedule = _get_schedule(regid, term)
            evals = None
            for section in schedule.sections:
                if section.curriculum_abbr == "TRAIN" and section.course_number == "102" and section.section_id == "A":
                    evals = _get_evaluations_by_section_and_student(section, 1033334)
                    break
            self.assertIsNotNone(evals)
            self.assertEqual(len(evals), 1)
            self.assertEqual(evals[0].section_sln, 13833)
            self.assertEqual(evals[0].eval_open_date, datetime.datetime(2013, 8, 23, 14, 0, 0, tzinfo=pytz.utc))
            self.assertEqual(evals[0].eval_close_date, datetime.datetime(2013, 8, 29, 6, 59, 59, tzinfo=pytz.utc))

            self.assertEqual(len(evals[0].instructor_ids), 3)
            self.assertEqual(evals[0].instructor_ids[0], 123456781)
            self.assertEqual(evals[0].instructor_ids[1], 123456782)
            self.assertEqual(evals[0].instructor_ids[2], 123456798)
示例#9
0
    def test_get_evaluations_by_section(self):
        with self.settings(RESTCLIENTS_SWS_DAO_CLASS=FDAO_SWS,
                           RESTCLIENTS_PWS_DAO_CLASS=FDAO_PWS,
                           RESTCLIENTS_IASYSTEM_DAO_CLASS=FDAO_IAS):

            regid = "9136CCB8F66711D5BE060004AC494FFE"
            term = Term()
            term.year = 2013
            term.quarter = "summer"
            section = Section()
            section.summer_term = "A-term"
            section.term = term
            schedule = _get_schedule(regid, term)
            evals = None
            for section in schedule.sections:
                if section.curriculum_abbr == 'ELCBUS':
                    evals = _get_evaluations_by_section_and_student(section,
                                                                    1443336)
                    break
            self.assertIsNotNone(evals)
            self.assertEqual(evals[0].section_sln, 13833)
            self.assertEqual(evals[0].eval_open_date,
                             datetime.datetime(2013, 7, 02,
                                               14, 0,
                                               tzinfo=pytz.utc))
            self.assertEqual(evals[0].eval_close_date,
示例#10
0
    def test_summer_term_overlaped(self):
        with self.settings(RESTCLIENTS_SWS_DAO_CLASS=FDAO_SWS):
            term = Term()
            term.year = 2013
            term.quarter = "summer"
            section = Section()
            section.summer_term = "A-term"
            section.term = term

            now_request = RequestFactory().get("/")
            now_request.session = {}
            now_request.session["myuw_override_date"] = "2013-07-10"
            self.assertTrue(summer_term_overlaped(now_request, section))
            section.summer_term = "Full-term"
            self.assertFalse(summer_term_overlaped(now_request, section))
            now_request = RequestFactory().get("/")
            now_request.session = {}
            now_request.session["myuw_override_date"] = "2013-08-10"
            self.assertTrue(summer_term_overlaped(now_request, section))

            section.summer_term = "B-term"
            self.assertTrue(summer_term_overlaped(now_request, section))

            now_request = RequestFactory().get("/")
            now_request.session = {}
            now_request.session["myuw_override_date"] = "2013-03-10"
            self.assertTrue(summer_term_overlaped(now_request, 'None'))
            self.assertTrue(summer_term_overlaped(now_request, '-'))
示例#11
0
    def test_filter_schedule_sections_by_summer_term(self):
        with self.settings(RESTCLIENTS_SWS_DAO_CLASS=FDAO_SWS,
                           RESTCLIENTS_PWS_DAO_CLASS=FDAO_PWS):
            regid = "9136CCB8F66711D5BE060004AC494FFE"
            term = Term()
            term.year = 2013
            term.quarter = "summer"
            schedule = _get_schedule(regid, term)
            # ensure it has both A and B terms
            has_a_term = False
            has_b_term = False
            for section in schedule.sections:
                if section.summer_term == "A-term":
                    has_a_term = True
                if section.summer_term == "B-term":
                    has_b_term = True
            self.assertTrue(has_a_term)
            self.assertTrue(has_b_term)

            filter_schedule_sections_by_summer_term(schedule, "A-term")
            # the B-term section no longer exists
            filtered_has_b_term = False
            filtered_has_a_term = False
            filtered_has_full_term = False
            for section in schedule.sections:
                if section.summer_term == "A-term":
                    filtered_has_a_term = True
                if section.summer_term == "B-term":
                    filtered_has_b_term = True
                if section.summer_term == "Full-term":
                    filtered_has_full_term = True

            self.assertFalse(filtered_has_b_term)
            self.assertTrue(filtered_has_full_term)
            self.assertTrue(filtered_has_a_term)
示例#12
0
    def test_get_subject_guide_seattle(self):
        with self.settings(RESTCLIENTS_SWS_DAO_CLASS=FDAO_SWS):
            regid = "9136CCB8F66711D5BE060004AC494FFE"
            term = Term()
            term.year = 2013
            term.quarter = "spring"
            schedule = _get_schedule(regid, term)
            for section in schedule.sections:
                # 404, general guide link
                if section.curriculum_abbr == 'TRAIN' and\
                        section.course_number == '101':
                    self.assertEquals(get_subject_guide_by_section(section),
                                      "http://guides.lib.uw.edu/research")

                # has subject guide link
                if section.curriculum_abbr == 'TRAIN' and\
                        section.course_number == '100':
                    self.assertEquals(
                        get_subject_guide_by_section(section),
                        "http://guides.lib.uw.edu/friendly.php?s=research/pnw")

                # has subject guide link
                if section.curriculum_abbr == 'PHYS' and\
                        section.course_number == '121':
                    self.assertEquals(
                        get_subject_guide_by_section(section),
                        "%s?%s" % ("http://guides.lib.uw.edu/friendly.php",
                                   "s=research/physics_astronomy"))
示例#13
0
    def test_get_by_schedule(self):
        regid = "9136CCB8F66711D5BE060004AC494FFE"
        term = Term()
        term.year = 2012
        term.quarter = "summer"
        schedule = _get_schedule(regid, term)

        buildings = get_buildings_by_schedule(schedule)
        self.assertEquals(len(buildings), 3)
示例#14
0
    def test_get_by_schedule(self):
        regid = "9136CCB8F66711D5BE060004AC494FFE"
        term = Term()
        term.year = 2012
        term.quarter = "summer"
        schedule = _get_schedule(regid, term)

        buildings = get_buildings_by_schedule(schedule)
        self.assertEquals(len(buildings), 3)
示例#15
0
    def test_by_campus(self):
        time_schedule_constructions = [
            TimeScheduleConstruction(campus="Seattle", is_on=False),
            TimeScheduleConstruction(campus="Tacoma", is_on=False),
            TimeScheduleConstruction(campus="Bothell", is_on=True),
        ]
        term = Term(year=2013, quarter="summer")
        term.time_schedule_construction = time_schedule_constructions
        section = Section(term=term)

        for campus in ["Seattle", "Tacoma", "Bothell", "PCE", ""]:
            section.course_campus = campus
            self.assertEquals(
                is_time_schedule_construction(section),
                True if campus == "Bothell" else False,
                "Campus: %s" % section.course_campus,
            )
示例#16
0
 def test_get_subject_guide_by_section(self):
     with self.settings(RESTCLIENTS_SWS_DAO_CLASS=FDAO_SWS,
                        RESTCLIENTS_PWS_DAO_CLASS=FDAO_PWS):
         regid = "9136CCB8F66711D5BE060004AC494FFE"
         term = Term()
         term.year = 2013
         term.quarter = "spring"
         schedule = _get_schedule(regid, term)
         for section in schedule.sections:
             if section.curriculum_abbr == 'TRAIN':
                 self.assertEquals(
                     get_subject_guide_by_section(section),
                     "http://www.lib.washington.edu/subject/")
             if section.curriculum_abbr == 'PHYS':
                 self.assertEquals(
                     get_subject_guide_by_section(section),
                     "http://guides.lib.washington.edu/physics_astronomy")
示例#17
0
    def test_sections_by_delegate_and_term(self):
        with self.settings(RESTCLIENTS_SWS_DAO_CLASS=SWSF,
                           RESTCLIENTS_PWS_DAO_CLASS=PWSF):

            term = Term(quarter="summer", year=2013)
            delegate = Person(uwregid="FBB38FE46A7C11D5A4AE0004AC494FFE")

            sections = get_sections_by_delegate_and_term(delegate, term)
            self.assertEquals(len(sections), 2)
示例#18
0
    def test_changed_sections_by_term(self):
        with self.settings(RESTCLIENTS_SWS_DAO_CLASS=SWSF,
                           RESTCLIENTS_PWS_DAO_CLASS=PWSF):

            changed_date = datetime(2013, 12, 12).date()
            term = Term(quarter="winter", year=2013)
            sections = get_changed_sections_by_term(changed_date, term)

            self.assertEquals(len(sections), 2)
示例#19
0
文件: thrive.py 项目: vegitron/myuw
    def test_get_offset(self):
        with self.settings(RESTCLIENTS_SWS_DAO_CLASS=FDAO_SWS,
                           RESTCLIENTS_PWS_DAO_CLASS=FDAO_PWS):
            term = Term()
            term.year = 2013
            term.quarter = "autumn"
            term.first_day_quarter = datetime.date(2013, 9, 11)

            date_prev = datetime.date(2013, 9, 10)
            date_equal = datetime.date(2013, 9, 11)
            date_post = datetime.date(2013, 9, 12)

            offset_prev = _get_offset(date_prev, term)
            self.assertEqual(offset_prev, -1)

            offset_equal = _get_offset(date_equal, term)
            self.assertEqual(offset_equal, 0)

            offset_post = _get_offset(date_post, term)
            self.assertEqual(offset_post, 1)
示例#20
0
    def test_get_offset(self):
        with self.settings(RESTCLIENTS_SWS_DAO_CLASS=FDAO_SWS,
                           RESTCLIENTS_PWS_DAO_CLASS=FDAO_PWS):
            term = Term()
            term.year = 2013
            term.quarter = "autumn"
            term.first_day_quarter = datetime.date(2013, 9, 11)

            date_prev = datetime.date(2013, 9, 10)
            date_equal = datetime.date(2013, 9, 11)
            date_post = datetime.date(2013, 9, 12)

            offset_prev = _get_offset(date_prev, term)
            self.assertEqual(offset_prev, -1)

            offset_equal = _get_offset(date_equal, term)
            self.assertEqual(offset_equal, 0)

            offset_post = _get_offset(date_post, term)
            self.assertEqual(offset_post, 1)
示例#21
0
 def test_get_subject_guide_bothell(self):
     with self.settings(RESTCLIENTS_SWS_DAO_CLASS=FDAO_SWS,
                        RESTCLIENTS_PWS_DAO_CLASS=FDAO_PWS):
         regid = "FE36CCB8F66711D5BE060004AC494FCD"
         term = Term()
         term.year = 2013
         term.quarter = "spring"
         schedule = _get_schedule(regid, term)
         for section in schedule.sections:
             # has subject guide link
             if section.curriculum_abbr == 'BISSEB' and\
                     section.course_number == '259':
                 self.assertEquals(
                     get_subject_guide_by_section(section),
                     "http://guides.lib.uw.edu/bothell/businternational")
             # 404, general guide link
             if section.curriculum_abbr == 'BCWRIT' and\
                     section.course_number == '500':
                 self.assertEquals(get_subject_guide_by_section(section),
                                   "http://guides.lib.uw.edu/bothell/")
示例#22
0
文件: library.py 项目: vegitron/myuw
 def test_get_subject_guide_bothell(self):
     with self.settings(RESTCLIENTS_SWS_DAO_CLASS=FDAO_SWS,
                        RESTCLIENTS_PWS_DAO_CLASS=FDAO_PWS):
         regid = "FE36CCB8F66711D5BE060004AC494FCD"
         term = Term()
         term.year = 2013
         term.quarter = "spring"
         schedule = _get_schedule(regid, term)
         for section in schedule.sections:
             # has subject guide link
             if section.curriculum_abbr == 'BISSEB' and\
                     section.course_number == '259':
                 self.assertEquals(
                     get_subject_guide_by_section(section),
                     "http://guides.lib.uw.edu/bothell/businternational")
             # 404, general guide link
             if section.curriculum_abbr == 'BCWRIT' and\
                     section.course_number == '500':
                 self.assertEquals(
                     get_subject_guide_by_section(section),
                     "http://guides.lib.uw.edu/bothell/")
示例#23
0
    def test_has_summer_quarter_section(self):
        with self.settings(RESTCLIENTS_SWS_DAO_CLASS=FDAO_SWS,
                           RESTCLIENTS_PWS_DAO_CLASS=FDAO_PWS):
            regid = "9136CCB8F66711D5BE060004AC494FFE"
            term = Term()
            term.year = 2012
            term.quarter = "summer"
            schedule = _get_schedule(regid, term)
            self.assertTrue(has_summer_quarter_section(schedule))

            term = Term()
            term.year = 2012
            term.quarter = "autumn"
            self.assertRaises(DataFailureException, _get_schedule, regid, term)
示例#24
0
    def test_sections_by_curriculum_and_term(self):
        with self.settings(RESTCLIENTS_SWS_DAO_CLASS=SWSF,
                           RESTCLIENTS_PWS_DAO_CLASS=PWSF):

            term = Term(quarter="winter", year=2013)
            curriculum = Curriculum(label="ENDO")
            sections = get_sections_by_curriculum_and_term(curriculum, term)

            self.assertEquals(len(sections), 2)

            # Valid curriculum, with no file
            self.assertRaises(DataFailureException,
                              get_sections_by_curriculum_and_term,
                              Curriculum(label="FINN"), term)
示例#25
0
    def test_has_summer_quarter_section(self):
        with self.settings(RESTCLIENTS_SWS_DAO_CLASS=FDAO_SWS,
                           RESTCLIENTS_PWS_DAO_CLASS=FDAO_PWS):
            regid = "9136CCB8F66711D5BE060004AC494FFE"
            term = Term()
            term.year = 2012
            term.quarter = "summer"
            schedule = _get_schedule(regid, term)
            self.assertTrue(has_summer_quarter_section(schedule))

            term = Term()
            term.year = 2012
            term.quarter = "autumn"
            schedule = _get_schedule(regid, term)
            self.assertFalse(has_summer_quarter_section(schedule))
示例#26
0
    def test_get_schedule_by_regid_and_term(self):
        with self.settings(
                RESTCLIENTS_SWS_DAO_CLASS='restclients.dao_implementation.sws.File',
                RESTCLIENTS_PWS_DAO_CLASS='restclients.dao_implementation.pws.File'):
            term = Term(quarter="spring", year=2013)
            class_schedule = get_schedule_by_regid_and_term(
                '9136CCB8F66711D5BE060004AC494FFE',
                term)
            for section in class_schedule.sections:
                if section.section_label() == '2013,spring,TRAIN,100/A':
                    self.assertEquals(len(section.get_instructors()), 1)
                    self.assertEquals(section.student_credits, Decimal("%s" % 1.0))
                    self.assertEquals(section.student_grade, "X")
                    self.assertEquals(section.get_grade_date_str(), None)
                    self.assertTrue(section.is_primary_section)
                    self.assertEquals(section.is_auditor, False)

                if section.section_label() == '2013,spring,PHYS,121/AC':
                    self.assertEquals(section.student_credits, Decimal("%s" % 3.0))
                    self.assertEquals(section.student_grade, "4.0")
                    self.assertEquals(section.get_grade_date_str(), "2013-06-11")
                    self.assertFalse(section.is_primary_section)
                    self.assertEquals(section.is_auditor, False)

            class_schedule = get_schedule_by_regid_and_term(
                '9136CCB8F66711D5BE060004AC494FFE',
                term, False)
            for section in class_schedule.sections:
                if section.section_label() == '2013,spring,TRAIN,100/A':
                    self.assertEquals(len(section.get_instructors()), 0)

            class_schedule = get_schedule_by_regid_and_term(
                '12345678901234567890123456789012', term)
            for section in class_schedule.sections:
                if section.section_label() == '2013,spring,,MATH,125/G':
                    self.assertEquals(section.student_credits, Decimal("%s" % 5.0))
                    self.assertEquals(section.student_grade, "3.5")
                    self.assertEquals(section.is_auditor, True)
                    self.assertTrue(section.is_primary_section)
示例#27
0
def _json_to_term_model(term_data):
    """
    Returns a term model created from the passed json data.
    param: term_data loaded json data
    """

    strptime = datetime.strptime
    day_format = "%Y-%m-%d"
    datetime_format = "%Y-%m-%dT%H:%M:%S"

    term = TermModel()
    term.year = term_data["Year"]
    term.quarter = term_data["Quarter"]

    term.last_day_add = parse_sws_date(term_data["LastAddDay"])

    term.first_day_quarter = parse_sws_date(term_data["FirstDay"])

    term.last_day_instruction = parse_sws_date(term_data["LastDayOfClasses"])

    term.last_day_drop = parse_sws_date(term_data["LastDropDay"])

    term.census_day = parse_sws_date(term_data["CensusDay"])

    if term_data["ATermLastDay"] is not None:
        term.aterm_last_date = parse_sws_date(term_data["ATermLastDay"])

    if term_data["BTermFirstDay"] is not None:
        term.bterm_first_date = parse_sws_date(term_data["BTermFirstDay"])

    if term_data["LastAddDayATerm"] is not None:
        term.aterm_last_day_add = parse_sws_date(term_data["LastAddDayATerm"])

    if term_data["LastAddDayBTerm"] is not None:
        term.bterm_last_day_add = parse_sws_date(term_data["LastAddDayBTerm"])

    term.last_final_exam_date = parse_sws_date(term_data["LastFinalExamDay"])

    term.grading_period_open = strptime(term_data["GradingPeriodOpen"],
                                        datetime_format)

    if term_data["GradingPeriodOpenATerm"] is not None:
        term.aterm_grading_period_open = strptime(
            term_data["GradingPeriodOpenATerm"], datetime_format)

    term.grading_period_close = strptime(term_data["GradingPeriodClose"],
                                         datetime_format)

    term.grade_submission_deadline = strptime(
        term_data["GradeSubmissionDeadline"], datetime_format)

    term.registration_services_start = parse_sws_date(
        term_data["RegistrationServicesStart"])

    term.registration_period1_start = parse_sws_date(
        term_data["RegistrationPeriods"][0]["StartDate"])
    term.registration_period1_end = parse_sws_date(
        term_data["RegistrationPeriods"][0]["EndDate"])

    term.registration_period2_start = parse_sws_date(
        term_data["RegistrationPeriods"][1]["StartDate"])
    term.registration_period2_end = parse_sws_date(
        term_data["RegistrationPeriods"][1]["EndDate"])

    term.registration_period3_start = parse_sws_date(
        term_data["RegistrationPeriods"][2]["StartDate"])
    term.registration_period3_end = parse_sws_date(
        term_data["RegistrationPeriods"][2]["EndDate"])

    term.time_schedule_construction = []
    for campus in term_data["TimeScheduleConstruction"]:
        tsc = TimeScheduleConstruction(
            campus=campus.lower(),
            is_on=(term_data["TimeScheduleConstruction"][campus] is True))
        term.time_schedule_construction.append(tsc)

    term.clean_fields()
    return term
示例#28
0
    def test_multiple_instructor(self):
        with self.settings(
            RESTCLIENTS_SWS_DAO_CLASS=FDAO_SWS,
            RESTCLIENTS_PWS_DAO_CLASS=FDAO_PWS,
            RESTCLIENTS_IASYSTEM_DAO_CLASS=FDAO_IAS,
        ):

            regid = "9136CCB8F66711D5BE060004AC494FFE"
            term = Term()
            term.year = 2013
            term.quarter = "spring"
            schedule = _get_schedule(regid, term)
            evals = None
            for section in schedule.sections:
                if section.curriculum_abbr == "TRAIN" and section.course_number == "100" and section.section_id == "A":
                    evals = _get_evaluations_by_section_and_student(section, 1033334)
                    break
            self.assertIsNotNone(evals)
            self.assertEqual(len(evals), 3)
            self.assertEqual(evals[0].section_sln, 17169)
            self.assertEqual(evals[0].eval_open_date, datetime.datetime(2013, 5, 30, 15, 0, 0, tzinfo=pytz.utc))
            self.assertEqual(evals[0].eval_close_date, datetime.datetime(2013, 7, 1, 7, 59, 59, tzinfo=pytz.utc))
            self.assertEqual(evals[1].eval_open_date, datetime.datetime(2013, 6, 5, 7, 0, 0, tzinfo=pytz.utc))
            self.assertEqual(evals[1].eval_close_date, datetime.datetime(2013, 6, 17, 6, 59, 59, tzinfo=pytz.utc))
            self.assertEqual(evals[2].eval_open_date, datetime.datetime(2013, 6, 10, 7, 0, 0, tzinfo=pytz.utc))
            self.assertEqual(evals[2].eval_close_date, datetime.datetime(2013, 6, 19, 6, 59, 59, tzinfo=pytz.utc))
            now_request = RequestFactory().get("/")
            now_request.session = {}
            now_request.session["myuw_override_date"] = "2013-05-30"
            json_data = json_for_evaluation(now_request, evals, None)
            self.assertIsNone(json_data)
            # after show date and open dates of 1 eval
            now_request.session = {}
            now_request.session["myuw_override_date"] = "2013-05-31"
            json_data = json_for_evaluation(now_request, evals, None)
            self.assertIsNotNone(json_data)
            self.assertEqual(len(json_data["evals"]), 1)
            self.assertEqual(json_data["close_date"], "2013-07-01T07:59:59+00:00")
            # after open dates of 1 eval
            now_request.session = {}
            now_request.session["myuw_override_date"] = "2013-06-04"
            json_data = json_for_evaluation(now_request, evals, None)
            self.assertIsNotNone(json_data)
            self.assertEqual(len(json_data["evals"]), 1)
            self.assertEqual(json_data["close_date"], "2013-07-01T07:59:59+00:00")
            # after open dates of two evals
            now_request.session = {}
            now_request.session["myuw_override_date"] = "2013-06-05"
            json_data = json_for_evaluation(now_request, evals, None)
            self.assertIsNotNone(json_data)
            self.assertEqual(len(json_data["evals"]), 2)
            self.assertEqual(json_data["close_date"], "2013-06-17T06:59:59+00:00")
            # after open dates of three evals
            now_request.session = {}
            now_request.session["myuw_override_date"] = "2013-06-10"
            json_data = json_for_evaluation(now_request, evals, None)
            self.assertIsNotNone(json_data)
            self.assertEqual(len(json_data["evals"]), 3)
            self.assertEqual(json_data["close_date"], "2013-06-17T06:59:59+00:00")
            # after close date of one eval
            now_request.session = {}
            now_request.session["myuw_override_date"] = "2013-06-17"
            json_data = json_for_evaluation(now_request, evals, None)
            self.assertEqual(len(json_data["evals"]), 2)
            self.assertEqual(json_data["close_date"], "2013-06-19T06:59:59+00:00")
            # after close date of two evals
            now_request.session = {}
            now_request.session["myuw_override_date"] = "2013-06-19"
            json_data = json_for_evaluation(now_request, evals, None)
            self.assertEqual(len(json_data["evals"]), 1)
            self.assertEqual(json_data["close_date"], "2013-07-01T07:59:59+00:00")
示例#29
0
    def test_multiple_evals(self):
        with self.settings(RESTCLIENTS_SWS_DAO_CLASS=FDAO_SWS,
                           RESTCLIENTS_PWS_DAO_CLASS=FDAO_PWS,
                           RESTCLIENTS_IASYSTEM_DAO_CLASS=FDAO_IAS):

            regid = "9136CCB8F66711D5BE060004AC494FFE"
            term = Term()
            term.year = 2013
            term.quarter = "spring"
            schedule = _get_schedule(regid, term)
            evals = None
            for section in schedule.sections:
                if section.curriculum_abbr == 'TRAIN' and\
                        section.course_number == '100' and\
                        section.section_id == 'A':
                    evals = _get_evaluations_by_section_and_student(
                        section, 1033334)
                    break
            self.assertIsNotNone(evals)
            self.assertEqual(len(evals), 3)
            self.assertEqual(evals[0].section_sln, 17169)
            self.assertEqual(
                evals[0].eval_open_date,
                datetime.datetime(2013, 5, 30, 15, 0, 0, tzinfo=pytz.utc))
            self.assertEqual(
                evals[0].eval_close_date,
                datetime.datetime(2013, 7, 1, 7, 59, 59, tzinfo=pytz.utc))
            self.assertFalse(evals[0].is_completed)
            self.assertEqual(
                evals[1].eval_open_date,
                datetime.datetime(2013, 6, 5, 7, 0, 0, tzinfo=pytz.utc))
            self.assertEqual(
                evals[1].eval_close_date,
                datetime.datetime(2013, 6, 17, 6, 59, 59, tzinfo=pytz.utc))
            self.assertFalse(evals[1].is_completed)
            self.assertEqual(
                evals[2].eval_open_date,
                datetime.datetime(2013, 6, 10, 7, 0, 0, tzinfo=pytz.utc))
            self.assertEqual(
                evals[2].eval_close_date,
                datetime.datetime(2013, 6, 19, 6, 59, 59, tzinfo=pytz.utc))
            self.assertTrue(evals[2].is_completed)
            now_request = RequestFactory().get("/")
            now_request.session = {}
            now_request.session["myuw_override_date"] = "2013-05-30"
            json_data = json_for_evaluation(now_request, evals, None)
            self.assertEqual(len(json_data), 0)

            # open dates of 1 eval
            now_request = RequestFactory().get("/")
            now_request.session = {}
            now_request.session["myuw_override_date"] = "2013-05-31"
            json_data = json_for_evaluation(now_request, evals, None)
            self.assertIsNotNone(json_data)
            self.assertEqual(len(json_data), 1)
            self.assertEqual(json_data[0]['close_date'],
                             "2013-07-01 07:59:59 UTC+0000")
            # after open dates of 1 eval
            now_request = RequestFactory().get("/")
            now_request.session = {}
            now_request.session["myuw_override_date"] = "2013-06-04"
            json_data = json_for_evaluation(now_request, evals, None)
            self.assertIsNotNone(json_data)
            self.assertEqual(len(json_data), 1)

            # after open dates of two evals
            now_request = RequestFactory().get("/")
            now_request.session = {}
            now_request.session["myuw_override_date"] = "2013-06-05"
            json_data = json_for_evaluation(now_request, evals, None)
            self.assertIsNotNone(json_data)
            self.assertEqual(len(json_data), 2)
            self.assertEqual(json_data[0]['close_date'],
                             "2013-07-01 07:59:59 UTC+0000")
            self.assertEqual(json_data[1]['close_date'],
                             "2013-06-17 06:59:59 UTC+0000")

            # after open dates of three evals
            now_request = RequestFactory().get("/")
            now_request.session = {}
            now_request.session["myuw_override_date"] = "2013-06-10"
            json_data = json_for_evaluation(now_request, evals, None)
            self.assertIsNotNone(json_data)
            self.assertEqual(len(json_data), 2)

            # after close date of one eval
            now_request = RequestFactory().get("/")
            now_request.session = {}
            now_request.session["myuw_override_date"] = "2013-06-17"
            json_data = json_for_evaluation(now_request, evals, None)
            self.assertEqual(len(json_data), 1)
            self.assertEqual(json_data[0]['close_date'],
                             "2013-07-01 07:59:59 UTC+0000")

            # after close date of two evals
            now_request = RequestFactory().get("/")
            now_request.session = {}
            now_request.session["myuw_override_date"] = "2013-06-19"
            json_data = json_for_evaluation(now_request, evals, None)
            self.assertEqual(len(json_data), 1)

            # after close date of last eval
            now_request = RequestFactory().get("/")
            now_request.session = {}
            now_request.session["myuw_override_date"] = "2013-07-02"
            json_data = json_for_evaluation(now_request, evals, None)
            self.assertEqual(len(json_data), 0)
示例#30
0
    def test_mock_data_fake_grading_window(self):
        with self.settings(RESTCLIENTS_SWS_DAO_CLASS=
                           'restclients.dao_implementation.sws.File',
                           RESTCLIENTS_PWS_DAO_CLASS=
                           'restclients.dao_implementation.pws.File'):

            sws = SWS()

            # backwards compatible for term
            term = sws.get_term_by_year_and_quarter(2013, 'spring')
            self.assertEquals(term.year, 2013)
            self.assertEquals(term.quarter, 'spring')

            term = sws.get_current_term()
            self.assertEquals(term.year, 2013)
            self.assertEquals(term.quarter, 'spring')

            prev_term = sws.get_previous_term()
            self.assertEquals(prev_term.year, 2013)
            self.assertEquals(prev_term.quarter, 'winter')

            next_term = sws.get_next_term()
            self.assertEquals(next_term.year, 2013)
            self.assertEquals(next_term.quarter, 'summer')

            term_before = sws.get_term_before(next_term)
            self.assertEquals(term_before.year, 2013)
            self.assertEquals(term_before.quarter, 'spring')

            term_after = sws.get_term_after(prev_term)
            self.assertEquals(term_after.year, 2013)
            self.assertEquals(term_after.quarter, 'spring')

            # backwards compatible for section
            section = sws.get_section_by_label('2013,winter,ASIAN,203/A')
            joint_sections = sws.get_joint_sections(section)
            self.assertEquals(len(joint_sections), 1)

            section = sws.get_section_by_url(
                '/student/v5/course/2013,summer,TRAIN,100/A.json')
            sws.get_linked_sections(section)
            section.linked_section_urls = ['2012,summer,TRAIN,100/A']
            self.assertRaises(InvalidSectionURL, sws.get_linked_sections,
                              section)

            term = Term(quarter="summer", year=2013)
            person = Person(uwregid="FBB38FE46A7C11D5A4AE0004AC494FFE")
            sections = sws.get_sections_by_instructor_and_term(person, term)
            self.assertEquals(len(sections), 1)

            sections = sws.get_sections_by_delegate_and_term(person, term)
            self.assertEquals(len(sections), 2)

            term = Term(quarter="winter", year=2013)
            curriculum = Curriculum(label="ENDO")
            sections = sws.get_sections_by_curriculum_and_term(
                curriculum, term)
            self.assertEquals(len(sections), 2)

            # backwards compatible for section_status
            section_status = sws.get_section_status_by_label(
                '2012,autumn,CSE,100/W')
            self.assertEquals(section_status.sln, 12588)

            # backwards compatible for registration
            section = sws.get_section_by_label('2013,winter,DROP_T,100/A')
            registrations = sws.get_active_registrations_for_section(section)
            self.assertEquals(len(registrations), 0)
            registrations = sws.get_all_registrations_for_section(section)
            self.assertEquals(len(registrations), 1)

            term = sws.get_current_term()
            sws.schedule_for_regid_and_term('9136CCB8F66711D5BE060004AC494FFE',
                                            term)
            # backwards compatible for enrollment
            grades = sws.grades_for_regid_and_term(
                '9136CCB8F66711D5BE060004AC494FFE', term)
            self.assertEquals(grades.user.uwnetid, "javerage")

            # backwards compatible for campus
            campuses = sws.get_all_campuses()
            self.assertEquals(len(campuses), 3)

            # backwards compatible for college
            colleges = sws.get_all_colleges()
            self.assertEquals(len(colleges), 20)

            # backwards compatible for department
            college = College(label="MED")
            depts = sws.get_departments_for_college(college)
            self.assertEquals(len(depts), 30)

            # backwards compatible for curriculum
            department = Department(label="EDUC")
            curricula = sws.get_curricula_for_department(department)
            self.assertEquals(len(curricula), 7)

            term = Term(quarter='winter', year=2013)
            curricula = sws.get_curricula_for_term(term)
            self.assertEquals(len(curricula), 423)
示例#31
0
def _json_to_term_model(term_data):
    """
    Returns a term model created from the passed json data.
    param: term_data loaded json data
    """

    strptime = datetime.strptime
    day_format = "%Y-%m-%d"
    datetime_format = "%Y-%m-%dT%H:%M:%S"

    term = TermModel()
    term.year = term_data["Year"]
    term.quarter = term_data["Quarter"]

    term.last_day_add = parse_sws_date(term_data["LastAddDay"])

    term.first_day_quarter = parse_sws_date(term_data["FirstDay"])

    term.last_day_instruction = parse_sws_date(term_data["LastDayOfClasses"])

    term.last_day_drop = parse_sws_date(term_data["LastDropDay"])

    if term_data["ATermLastDay"] is not None:
        term.aterm_last_date = parse_sws_date(term_data["ATermLastDay"])

    if term_data["BTermFirstDay"] is not None:
        term.bterm_first_date = parse_sws_date(term_data["BTermFirstDay"])

    if term_data["LastAddDayATerm"] is not None:
        term.aterm_last_day_add = parse_sws_date(term_data["LastAddDayATerm"])

    if term_data["LastAddDayBTerm"] is not None:
        term.bterm_last_day_add = parse_sws_date(term_data["LastAddDayBTerm"])

    term.last_final_exam_date = parse_sws_date(term_data["LastFinalExamDay"])

    term.grading_period_open = strptime(
        term_data["GradingPeriodOpen"], datetime_format)

    if term_data["GradingPeriodOpenATerm"] is not None:
        term.aterm_grading_period_open = strptime(
            term_data["GradingPeriodOpenATerm"], datetime_format)

    term.grading_period_close = strptime(
        term_data["GradingPeriodClose"], datetime_format)

    term.grade_submission_deadline = strptime(
        term_data["GradeSubmissionDeadline"], datetime_format)

    term.registration_services_start = parse_sws_date(term_data["RegistrationServicesStart"])

    term.registration_period1_start = parse_sws_date(term_data["RegistrationPeriods"][0]["StartDate"])
    term.registration_period1_end = parse_sws_date(term_data["RegistrationPeriods"][0]["EndDate"])

    term.registration_period2_start = parse_sws_date(term_data["RegistrationPeriods"][1]["StartDate"])
    term.registration_period2_end = parse_sws_date(term_data["RegistrationPeriods"][1]["EndDate"])

    term.registration_period3_start = parse_sws_date(term_data["RegistrationPeriods"][2]["StartDate"])
    term.registration_period3_end = parse_sws_date(term_data["RegistrationPeriods"][2]["EndDate"])

    term.time_schedule_construction = []
    for campus in term_data["TimeScheduleConstruction"]:
        tsc = TimeScheduleConstruction(
            campus=campus.lower(),
            is_on=(term_data["TimeScheduleConstruction"][campus] is True))
        term.time_schedule_construction.append(tsc)

    term.clean_fields()
    return term