Fix deprecation warnings surfaced by pytest output

cms/db/types.py

@@ -138,7 +138,7 @@ class FilenameSchema(TypeDecorator):
     @classmethod
     def get_create_command(cls):
         return DDL("CREATE DOMAIN %(domain)s VARCHAR "
-                   "CHECK (VALUE ~ '^[A-Za-z0-9_.-]+(\.%%l)?$') "
+                   "CHECK (VALUE ~ '^[A-Za-z0-9_.-]+(.%%l)?$') "
                    "CHECK (VALUE != '.') "
                    "CHECK (VALUE != '..')",
                    context={"domain": cls.domain_name})
@@ -187,7 +187,7 @@ class FilenameSchemaArray(TypeDecorator):
         return DDL("CREATE DOMAIN %(domain)s VARCHAR[] "
                    "CHECK (array_to_string(VALUE, '') ~ '^[A-Za-z0-9_.%%-]*$') "
                    "CHECK (array_to_string(VALUE, ',') "
-                   "       ~ '^([A-Za-z0-9_.-]+(\.%%l)?(,|$))*$') "
+                   "       ~ '^([A-Za-z0-9_.-]+(.%%l)?(,|$))*$') "
                    "CHECK ('.' != ALL(VALUE)) "
                    "CHECK ('..' != ALL(VALUE))",
                    context={"domain": cls.domain_name})

cms/io/web_service.py

@@ -27,7 +27,8 @@ except ImportError:
     import tornado.wsgi as tornado_wsgi
 from gevent.pywsgi import WSGIServer
 from werkzeug.contrib.fixers import ProxyFix
-from werkzeug.wsgi import DispatcherMiddleware, SharedDataMiddleware
+from werkzeug.middleware.dispatcher import DispatcherMiddleware
+from werkzeug.middleware.shared_data import SharedDataMiddleware
 
 from cms.db.filecacher import FileCacher
 from cms.server.file_middleware import FileServerMiddleware

cms/server/contest/server.py

@@ -39,7 +39,7 @@
 
 import logging
 
-from werkzeug.wsgi import SharedDataMiddleware
+from werkzeug.middleware.shared_data import SharedDataMiddleware
 
 from cms import ConfigError, ServiceCoord, config
 from cms.io import WebService

cmstestsuite/unit_tests/grading/steps/utils_test.py

@@ -122,7 +122,7 @@ class TestGenericStep(unittest.TestCase):
                              collect_output=True)
 
         # 2 commands executed, with exec_num 0 and 1
-        self.assertEquals(self.sandbox.exec_num, 1)
+        self.assertEqual(self.sandbox.exec_num, 1)
         # Stats are the combination of the two.
         self.assertEqual(stats, get_stats(1.1,  # sum
                                           5.5,  # sum
@@ -141,7 +141,7 @@ class TestGenericStep(unittest.TestCase):
                              collect_output=True)
 
         # 1 command executed (generic terminates early), with exec_num 0.
-        self.assertEquals(self.sandbox.exec_num, 0)
+        self.assertEqual(self.sandbox.exec_num, 0)
         # Stats are only for the first command.
         self.assertEqual(stats, get_stats(
             0.1, 0.5, 1000 * 1024, Sandbox.EXIT_NONZERO_RETURN,
@@ -156,7 +156,7 @@ class TestGenericStep(unittest.TestCase):
         stats = generic_step(self.sandbox, TWO_COMMANDS, "name")
 
         # 1 command executed (generic terminates early), with exec_num 0.
-        self.assertEquals(self.sandbox.exec_num, 0)
+        self.assertEqual(self.sandbox.exec_num, 0)
         self.assertIsNone(stats)
 
     def test_invalid_utf8_in_output(self):

cmstestsuite/unit_tests/service/LogServiceTest.py

@@ -59,21 +59,21 @@ class TestLogService(unittest.TestCase):
             exc_text=TestLogService.EXC_TEXT + severity)
         last_message = self.service.last_messages()[-1]
         if saved:
-            self.assertEquals(last_message["message"],
+            self.assertEqual(last_message["message"],
                               TestLogService.MSG + severity)
-            self.assertEquals(last_message["coord"],
+            self.assertEqual(last_message["coord"],
                               TestLogService.SERVICE_NAME + severity +
                               "," + ("%d" % TestLogService.SERVICE_SHARD))
-            self.assertEquals(last_message["operation"],
+            self.assertEqual(last_message["operation"],
                               TestLogService.OPERATION + severity)
-            self.assertEquals(last_message["severity"],
+            self.assertEqual(last_message["severity"],
                               severity)
-            self.assertEquals(last_message["timestamp"],
+            self.assertEqual(last_message["timestamp"],
                               TestLogService.CREATED)
-            self.assertEquals(last_message["exc_text"],
+            self.assertEqual(last_message["exc_text"],
                               TestLogService.EXC_TEXT + severity)
         else:
-            self.assertNotEquals(last_message["severity"], severity)
+            self.assertNotEqual(last_message["severity"], severity)
 
 
 if __name__ == "__main__":

cmstestsuite/unit_tests/service/WorkerTest.py

@@ -58,7 +58,7 @@ class TestWorker(unittest.TestCase):
             self.assertTrue(ret_job_group.jobs[0].success)
 
         cms.service.Worker.get_task_type.assert_has_calls(calls)
-        self.assertEquals(task_type.call_count, n_jobs)
+        self.assertEqual(task_type.call_count, n_jobs)
 
     def test_execute_job_failure(self):
         """Executes two unsuccessful jobs.
@@ -78,8 +78,8 @@ class TestWorker(unittest.TestCase):
         for job_group in results:
             for job in job_group.jobs:
                 self.assertFalse(job.success)
-        self.assertEquals(cms.service.Worker.get_task_type.call_count, n_jobs)
-        self.assertEquals(task_type.call_count, n_jobs)
+        self.assertEqual(cms.service.Worker.get_task_type.call_count, n_jobs)
+        self.assertEqual(task_type.call_count, n_jobs)
 
     def test_execute_job_tasktype_raise(self):
         """Executes two jobs raising exceptions.
@@ -96,8 +96,8 @@ class TestWorker(unittest.TestCase):
                 JobGroup.import_from_dict(
                     self.service.execute_job_group(job_group.export_to_dict()))
 
-        self.assertEquals(cms.service.Worker.get_task_type.call_count, n_jobs)
-        self.assertEquals(task_type.call_count, n_jobs)
+        self.assertEqual(cms.service.Worker.get_task_type.call_count, n_jobs)
+        self.assertEqual(task_type.call_count, n_jobs)
 
     def test_execute_job_subsequent_success(self):
         """Executes three successful jobs, then four others.
@@ -114,7 +114,7 @@ class TestWorker(unittest.TestCase):
                 self.service.execute_job_group(job_group.export_to_dict()))
 
         cms.service.Worker.get_task_type.assert_has_calls(calls_a)
-        self.assertEquals(task_type_a.call_count, n_jobs_a)
+        self.assertEqual(task_type_a.call_count, n_jobs_a)
 
         n_jobs_b = 4
         jobs_b, calls_b = TestWorker.new_jobs(n_jobs_b, prefix="b")
@@ -127,7 +127,7 @@ class TestWorker(unittest.TestCase):
                 self.service.execute_job_group(job_group.export_to_dict()))
 
         cms.service.Worker.get_task_type.assert_has_calls(calls_b)
-        self.assertEquals(task_type_b.call_count, n_jobs_b)
+        self.assertEqual(task_type_b.call_count, n_jobs_b)
 
     def test_execute_job_subsequent_locked(self):
         """Executes a long job, then another one that should fail
@@ -173,7 +173,7 @@ class TestWorker(unittest.TestCase):
             JobGroup.import_from_dict(
                 self.service.execute_job_group(job_group.export_to_dict()))
         cms.service.Worker.get_task_type.assert_has_calls(calls_a)
-        self.assertEquals(task_type_a.call_count, n_jobs_a)
+        self.assertEqual(task_type_a.call_count, n_jobs_a)
 
         n_jobs_b = 3
         jobs_b, calls_b = TestWorker.new_jobs(n_jobs_b)
@@ -186,7 +186,7 @@ class TestWorker(unittest.TestCase):
                 self.service.execute_job_group(job_group.export_to_dict()))
 
         cms.service.Worker.get_task_type.assert_has_calls(calls_b)
-        self.assertEquals(task_type_b.call_count, n_jobs_b)
+        self.assertEqual(task_type_b.call_count, n_jobs_b)
 
     def test_execute_job_group_success(self):
         """Executes two successful job groups.
@@ -202,7 +202,7 @@ class TestWorker(unittest.TestCase):
                 self.service.execute_job_group(job_group.export_to_dict()))
 
         cms.service.Worker.get_task_type.assert_has_calls(calls)
-        self.assertEquals(task_type.call_count, sum(n_jobs))
+        self.assertEqual(task_type.call_count, sum(n_jobs))
 
     def test_execute_job_group_mixed_success(self):
         """Executes three job groups with mixed grades of success.
@@ -213,7 +213,7 @@ class TestWorker(unittest.TestCase):
             [True] * n_jobs[0] +
             [False] + [True] * (n_jobs[1] - 1) +
             [False] * n_jobs[2])
-        self.assertEquals(sum(n_jobs), len(expected_success))
+        self.assertEqual(sum(n_jobs), len(expected_success))
 
         job_groups, calls = TestWorker.new_job_groups(n_jobs)
         task_type = FakeTaskType(expected_success)
@@ -231,7 +231,7 @@ class TestWorker(unittest.TestCase):
                 expected_idx += 1
 
         cms.service.Worker.get_task_type.assert_has_calls(calls)
-        self.assertEquals(task_type.call_count, sum(n_jobs))
+        self.assertEqual(task_type.call_count, sum(n_jobs))
 
     def test_execute_job_group_mixed_exceptions(self):
         """Executes a job group with some exceptions.
@@ -239,7 +239,7 @@ class TestWorker(unittest.TestCase):
         """
         n_jobs = 4
         expected_success = [True, Exception(), False, True]
-        self.assertEquals(n_jobs, len(expected_success))
+        self.assertEqual(n_jobs, len(expected_success))
 
         job_groups, unused_calls = TestWorker.new_job_groups([n_jobs])
         task_type = FakeTaskType(expected_success)