Merge pull request #219 from uw-it-aca/develop

enable deprecation warnings when testing (#217)

README.md

@@ -3,7 +3,7 @@
 [![Build Status](https://github.com/uw-it-aca/uw-restclients-sws/workflows/tests/badge.svg?branch=main)](https://github.com/uw-it-aca/uw-restclients-sws/actions)
 [![Coverage Status](https://coveralls.io/repos/github/uw-it-aca/uw-restclients-sws/badge.svg?branch=main)](https://coveralls.io/github/uw-it-aca/uw-restclients-sws?branch=main)
 [![PyPi Version](https://img.shields.io/pypi/v/uw-restclients-sws.svg)](https://pypi.python.org/pypi/uw-restclients-sws)
-![Python versions](https://img.shields.io/pypi/pyversions/uw-restclients-sws.svg)
+![Python versions](https://img.shields.io/badge/python-3.10-blue.svg)
 
 Installation:
 

setup.py

@@ -25,7 +25,6 @@
     include_package_data=True,
     install_requires=['UW-RestClients-Core',
                       'UW-RestClients-PWS',
-                      'pytz',
                       'mock',
                      ],
     license='Apache License, Version 2.0',
@@ -40,5 +39,3 @@
         'Programming Language :: Python',
     ],
 )
-
-

uw_sws/dao.py

@@ -7,12 +7,11 @@
 import json
 import os
 import re
-import pytz
 from datetime import datetime, timedelta, timezone
 from os.path import abspath, dirname
 from restclients_core.dao import DAO, MockDAO
 
-SWS_TIMEZONE = pytz.timezone('America/Los_Angeles')
+SWS_TIMEZONE = timezone(timedelta(seconds=-8*60*60))
 
 
 def sws_now():

uw_sws/notice.py

@@ -6,7 +6,7 @@
  for notice resource
 """
 
-from datetime import timezone
+from datetime import datetime, timezone
 from dateutil import parser
 import logging
 from uw_sws.models import Notice, NoticeAttribute
@@ -27,7 +27,9 @@ def get_notices_by_regid(regid):
 
 def _str_to_utc(date_str):
     date = parser.parse(date_str)
-    return SWS_TIMEZONE.localize(date).astimezone(timezone.utc)
+    return datetime.combine(
+        date, datetime.min.time(), tzinfo=SWS_TIMEZONE).astimezone(
+            timezone.utc)
 
 
 def _notices_from_json(notice_data):

uw_sws/tests/compatible.py

@@ -15,11 +15,11 @@
 @fdao_pws_override
 class UtilFunctionTest(TestCase):
     def test_encode_section_label(self):
-        self.assertEquals(encode_section_label('2013,winter,C LIT,396/A'),
-                          '2013,winter,C%20LIT,396/A')
+        self.assertEqual(encode_section_label('2013,winter,C LIT,396/A'),
+                         '2013,winter,C%20LIT,396/A')
 
     def test_get_resource(self):
-        self.assertEquals(get_resource('/student/v5/campus.json'), (
+        self.assertEqual(get_resource('/student/v5/campus.json'), (
             "{u'PageSize': u'10', u'Campuses': [{u'CampusShortName': "
             "u'BOTHELL', u'Href': u'/student/v5/campus/BOTHELL.json', "
             "u'CampusName': u'UW Bothell', u'CampusFullName': u'UNIVERSITY "
@@ -40,33 +40,33 @@ def test_mock_data_fake_grading_window(self):
 
         # backwards compatible for term
         term = sws.get_term_by_year_and_quarter(2013, 'spring')
-        self.assertEquals(term.year, 2013)
-        self.assertEquals(term.quarter, 'spring')
+        self.assertEqual(term.year, 2013)
+        self.assertEqual(term.quarter, 'spring')
 
         term = sws.get_current_term()
-        self.assertEquals(term.year, 2013)
-        self.assertEquals(term.quarter, 'spring')
+        self.assertEqual(term.year, 2013)
+        self.assertEqual(term.quarter, 'spring')
 
         prev_term = sws.get_previous_term()
-        self.assertEquals(prev_term.year, 2013)
-        self.assertEquals(prev_term.quarter, 'winter')
+        self.assertEqual(prev_term.year, 2013)
+        self.assertEqual(prev_term.quarter, 'winter')
 
         next_term = sws.get_next_term()
-        self.assertEquals(next_term.year, 2013)
-        self.assertEquals(next_term.quarter, 'summer')
+        self.assertEqual(next_term.year, 2013)
+        self.assertEqual(next_term.quarter, 'summer')
 
         term_before = sws.get_term_before(next_term)
-        self.assertEquals(term_before.year, 2013)
-        self.assertEquals(term_before.quarter, 'spring')
+        self.assertEqual(term_before.year, 2013)
+        self.assertEqual(term_before.quarter, 'spring')
 
         term_after = sws.get_term_after(prev_term)
-        self.assertEquals(term_after.year, 2013)
-        self.assertEquals(term_after.quarter, 'spring')
+        self.assertEqual(term_after.year, 2013)
+        self.assertEqual(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)
+        self.assertEqual(len(joint_sections), 1)
 
         section = sws.get_section_by_url(
             '/student/v5/course/2013,summer,TRAIN,100/A.json')
@@ -78,55 +78,55 @@ def test_mock_data_fake_grading_window(self):
         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)
+        self.assertEqual(len(sections), 1)
 
         sections = sws.get_sections_by_delegate_and_term(person, term)
-        self.assertEquals(len(sections), 2)
+        self.assertEqual(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)
+        self.assertEqual(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)
+        self.assertEqual(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)
+        self.assertEqual(len(registrations), 0)
         registrations = sws.get_all_registrations_for_section(section)
-        self.assertEquals(len(registrations), 1)
+        self.assertEqual(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")
+        self.assertEqual(grades.user.uwnetid, "javerage")
 
         # backwards compatible for campus
         campuses = sws.get_all_campuses()
-        self.assertEquals(len(campuses), 3)
+        self.assertEqual(len(campuses), 3)
 
         # backwards compatible for college
         colleges = sws.get_all_colleges()
-        self.assertEquals(len(colleges), 20)
+        self.assertEqual(len(colleges), 20)
 
         # backwards compatible for department
         college = College(label="MED")
         depts = sws.get_departments_for_college(college)
-        self.assertEquals(len(depts), 30)
+        self.assertEqual(len(depts), 30)
 
         # backwards compatible for curriculum
         department = Department(label="EDUC")
         curricula = sws.get_curricula_for_department(department)
-        self.assertEquals(len(curricula), 7)
+        self.assertEqual(len(curricula), 7)
 
         term = Term(quarter='winter', year=2013)
         curricula = sws.get_curricula_for_term(term)
-        self.assertEquals(len(curricula), 423)
+        self.assertEqual(len(curricula), 423)

uw_sws/tests/test_adviser.py

@@ -12,10 +12,10 @@ class AdviserTest(TestCase):
     def test_get_advisers(self):
         advisers = get_advisers_by_regid(
             "9136CCB8F66711D5BE060004AC494FFE")
-        self.assertEquals(len(advisers), 1)
-        self.assertEquals(advisers[0].uwnetid, "uwhonors")
+        self.assertEqual(len(advisers), 1)
+        self.assertEqual(advisers[0].uwnetid, "uwhonors")
         self.assertTrue(advisers[0].is_honors_program())
-        self.assertEquals(
+        self.assertEqual(
             advisers[0].json_data(),
             {'booking_url': 'https://honors.uw.edu/advising/',
              'email_address': 'uwhonors@uw.edu',

uw_sws/tests/test_campus.py

@@ -14,5 +14,4 @@ class SWSTestCampus(TestCase):
 
     def test_all_campuses(self):
         campuses = get_all_campuses()
-
-        self.assertEquals(len(campuses), 3)
+        self.assertEqual(len(campuses), 3)

uw_sws/tests/test_college.py

@@ -14,4 +14,4 @@ class SWSTestCollege(TestCase):
 
     def test_all_colleges(self):
         colleges = get_all_colleges()
-        self.assertEquals(len(colleges), 20)
+        self.assertEqual(len(colleges), 20)

uw_sws/tests/test_curriculum.py

@@ -17,7 +17,7 @@ def test_curricula_for_department(self):
         department = Department(label="EDUC")
         curricula = get_curricula_by_department(department)
 
-        self.assertEquals(len(curricula), 7)
+        self.assertEqual(len(curricula), 7)
 
         # Valid department labels, no files for them
         self.assertRaises(DataFailureException,
@@ -38,7 +38,7 @@ def test_curricula_for_department(self):
         # Valid future_terms value
         curricula = get_curricula_by_department(department,
                                                 future_terms=0)
-        self.assertEquals(len(curricula), 7)
+        self.assertEqual(len(curricula), 7)
 
         # Invalid future_terms values
         self.assertRaises(ValueError,
@@ -59,10 +59,10 @@ def test_curricula_for_department(self):
     def test_curricula_for_term(self):
         term = Term(quarter='winter', year=2013)
         curricula = get_curricula_by_term(term)
-        self.assertEquals(len(curricula), 423)
+        self.assertEqual(len(curricula), 423)
 
         curricula = get_curricula_by_term(term, view_unpublished=True)
-        self.assertEquals(len(curricula), 423)
+        self.assertEqual(len(curricula), 423)
 
         # Valid terms, no files for them
         self.assertRaises(DataFailureException,

uw_sws/tests/test_dao.py

@@ -9,9 +9,9 @@
 class SWSTestDao(TestCase):
 
     def test_custom_headers(self):
-        self.assertEquals(SWS_DAO()._custom_headers('GET', '/', {}, None), {})
+        self.assertEqual(SWS_DAO()._custom_headers('GET', '/', {}, None), {})
         with override_settings(RESTCLIENTS_SWS_OAUTH_BEARER='token'):
-            self.assertEquals(
+            self.assertEqual(
                 SWS_DAO()._custom_headers('GET', '/', {}, None),
                 {'Authorization': 'Bearer token'}
             )

uw_sws/tests/test_degree.py

@@ -12,8 +12,8 @@ class AdviserTest(TestCase):
     def test_get_degrees(self):
         degrees = get_degrees_by_regid(
             "9136CCB8F66711D5BE060004AC494FFE")
-        self.assertEquals(len(degrees), 1)
-        self.assertEquals(
+        self.assertEqual(len(degrees), 1)
+        self.assertEqual(
             degrees[0].json_data(),
             {
                 'campus': 'SEATTLE',

uw_sws/tests/test_department.py

@@ -17,7 +17,7 @@ def test_departments_for_college(self):
         college = College(label="MED")
         depts = get_departments_by_college(college)
 
-        self.assertEquals(len(depts), 30)
+        self.assertEqual(len(depts), 30)
 
         # Valid department labels, no files for them
         self.assertRaises(DataFailureException,

uw_sws/tests/test_enrollment.py

@@ -21,31 +21,31 @@ def test_javerage_grades(self):
         grades = get_grades_by_regid_and_term(
             '9136CCB8F66711D5BE060004AC494FFE', term)
 
-        self.assertEquals(grades.term.year, 2013)
-        self.assertEquals(grades.term.quarter, "spring")
-        self.assertEquals(grades.user.uwnetid, "javerage")
-        self.assertEquals(grades.grade_points, 30)
-        self.assertEquals(grades.credits_attempted, 10)
-        self.assertEquals(grades.non_grade_credits, 2)
+        self.assertEqual(grades.term.year, 2013)
+        self.assertEqual(grades.term.quarter, "spring")
+        self.assertEqual(grades.user.uwnetid, "javerage")
+        self.assertEqual(grades.grade_points, 30)
+        self.assertEqual(grades.credits_attempted, 10)
+        self.assertEqual(grades.non_grade_credits, 2)
 
-        self.assertEquals(grades.grades[0].grade, 'CR')
-        self.assertEquals(grades.grades[2].grade, '3.1')
-        self.assertEquals(grades.grades[2].credits, '3.0')
-        self.assertEquals(grades.grades[2].section.course_number, '121')
+        self.assertEqual(grades.grades[0].grade, 'CR')
+        self.assertEqual(grades.grades[2].grade, '3.1')
+        self.assertEqual(grades.grades[2].credits, '3.0')
+        self.assertEqual(grades.grades[2].section.course_number, '121')
 
     def test_javerage_major(self):
         term = get_current_term()
         enrollment = get_enrollment_by_regid_and_term(
             '9136CCB8F66711D5BE060004AC494FFE', term)
-        self.assertEquals(enrollment.class_level, "SENIOR")
-        self.assertEquals(enrollment.is_honors, False)
-        self.assertEquals(len(enrollment.majors), 1)
-        self.assertEquals(enrollment.majors[0].campus, "Seattle")
-        self.assertEquals(
+        self.assertEqual(enrollment.class_level, "SENIOR")
+        self.assertEqual(enrollment.is_honors, False)
+        self.assertEqual(len(enrollment.majors), 1)
+        self.assertEqual(enrollment.majors[0].campus, "Seattle")
+        self.assertEqual(
             enrollment.majors[0].degree_name,
             "BACHELOR OF SCIENCE (APPLIED & COMPUTATIONAL MATH SCIENCES)")
-        self.assertEquals(enrollment.minors[0].campus, "Seattle")
-        self.assertEquals(enrollment.minors[0].name, "AMERICAN SIGN LANGUAGE")
+        self.assertEqual(enrollment.minors[0].campus, "Seattle")
+        self.assertEqual(enrollment.minors[0].name, "AMERICAN SIGN LANGUAGE")
         self.assertFalse(enrollment.is_non_matric())
         self.assertFalse(enrollment.has_unfinished_pce_course())
         self.assertFalse(enrollment.is_enroll_src_pce)
@@ -66,7 +66,7 @@ def test_offterm_enrolled_courses(self):
         term = get_term_by_year_and_quarter(2013, 'winter')
         enrollment = get_enrollment_by_regid_and_term(
             'AABBCCDDEEFFAABBCCDDEEFFAABBCCDC', term)
-        self.assertEquals(enrollment.class_level, u'NON_MATRIC')
+        self.assertEqual(enrollment.class_level, u'NON_MATRIC')
         self.assertTrue(enrollment.is_enroll_src_pce)
         self.assertTrue(enrollment.is_non_matric())
         self.assertTrue(enrollment.is_registered)
@@ -136,10 +136,10 @@ def test_enrollment_search(self):
         enrollment = result_dict.get(term)
         self.assertTrue(enrollment.is_registered)
         self.assertTrue(enrollment.is_non_matric())
-        self.assertEquals(enrollment.majors[0].college_abbr, "INDUG")
-        self.assertEquals(enrollment.majors[0].college_full_name,
-                          "INTERDISCIPLINARY UNDERGRADUATE PROGRAMS")
-        self.assertEquals(enrollment.majors[0].degree_level, 0)
+        self.assertEqual(enrollment.majors[0].college_abbr, "INDUG")
+        self.assertEqual(enrollment.majors[0].college_full_name,
+                         "INTERDISCIPLINARY UNDERGRADUATE PROGRAMS")
+        self.assertEqual(enrollment.majors[0].degree_level, 0)
         self.assertEqual(len(enrollment.unf_pce_courses), 3)
         self.assertTrue(
             "2013,spring,AAES,150/A" in enrollment.unf_pce_courses)
@@ -158,7 +158,7 @@ def test_enrollment_search(self):
         term0 = get_term_before(term)
         self.assertTrue(term0 in result_dict)
         enrollment0 = result_dict.get(term0)
-        self.assertEquals(enrollment.majors[0], enrollment0.majors[0])
+        self.assertEqual(enrollment.majors[0], enrollment0.majors[0])
         self.assertEqual(len(enrollment0.unf_pce_courses), 2)
 
         # regular course
@@ -169,14 +169,14 @@ def test_enrollment_search(self):
         self.assertTrue(term in result_dict)
         self.assertIsNotNone(result_dict.get(term))
         enrollment = result_dict.get(term)
-        self.assertEquals(enrollment.class_level, "SENIOR")
-        self.assertEquals(len(enrollment.majors), 1)
-        self.assertEquals(len(enrollment.minors), 1)
+        self.assertEqual(enrollment.class_level, "SENIOR")
+        self.assertEqual(len(enrollment.majors), 1)
+        self.assertEqual(len(enrollment.minors), 1)
         enroll_major = enrollment.majors[0]
-        self.assertEquals(enroll_major.college_abbr, None)
-        self.assertEquals(enroll_major.college_full_name, None)
-        self.assertEquals(enroll_major.degree_level, 1)
-        self.assertEquals(len(enrollment.minors), 1)
+        self.assertEqual(enroll_major.college_abbr, None)
+        self.assertEqual(enroll_major.college_full_name, None)
+        self.assertEqual(enroll_major.degree_level, 1)
+        self.assertEqual(len(enrollment.minors), 1)
         enroll_minor = enrollment.minors[0]
 
         term1 = get_term_by_year_and_quarter(2013, 'summer')
@@ -195,7 +195,7 @@ def test_enrollment_search(self):
         self.assertIsNotNone(result_dict.get(term3))
         enroll3 = result_dict.get(term3)
         self.assertTrue(enroll3.is_registered)
-        self.assertEquals(len(enroll3.minors), 1)
+        self.assertEqual(len(enroll3.minors), 1)
         enroll3_minor = enroll3.minors[0]
         self.assertTrue(enroll3_minor != enroll_minor)