use modern assertEqual and friends in tests

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: mattip

codespeed/commits/tests/test_git.py

@@ -57,4 +57,4 @@ def side_effect(cmd, *args, **kwargs):
             'short_commit_id': 'id',
             'tag': 'tag',
         }
-        self.assertEquals([expected], logs)
+        self.assertEqual([expected], logs)

codespeed/tests/test_models.py

@@ -104,7 +104,7 @@ def test_good_benchmark_change_beats_bad_average_trend(self):
                 self.make_result(x, rev=s1, benchmark=b1)
         self.make_result(changes[-2] * .97, rev=s1, benchmark=b1)
         rep = self.make_report(s1)
-        self.assertEquals('green', rep.colorcode)
+        self.assertEqual('green', rep.colorcode)
         self.assertIn('b1', rep.summary)
 
     def test_good_average_change_beats_bad_average_trend(self):
@@ -116,7 +116,7 @@ def test_good_average_change_beats_bad_average_trend(self):
                 self.make_result(x, rev=s1, benchmark=b1)
         self.make_result(changes[-2] * .92, rev=s1, benchmark=b1)
         rep = self.make_report(s1)
-        self.assertEquals('green', rep.colorcode)
+        self.assertEqual('green', rep.colorcode)
         self.assertIn('Average', rep.summary)
 
     def test_good_change_beats_good_trend(self):
@@ -156,7 +156,7 @@ def test_bad_change_beats_good_trend(self):
         rep = self.make_report(s1)
         self.assertIn('b1', rep.summary)
         self.assertNotIn('trend', rep.summary)
-        self.assertEquals('red', rep.colorcode)
+        self.assertEqual('red', rep.colorcode)
 
     def test_bad_beats_good_change(self):
         b1 = self.make_bench('b1')
@@ -184,7 +184,7 @@ def test_bigger_bad_beats_smaller_bad(self):
 
         rep = self.make_report(s2)
         self.assertIn('b1', rep.summary)
-        self.assertEquals('red', rep.colorcode)
+        self.assertEqual('red', rep.colorcode)
 
     def test_multiple_quantities(self):
         b1 = self.make_bench('b1', quantity='Space', units='bytes')
@@ -195,8 +195,8 @@ def test_multiple_quantities(self):
         self.make_result(1.5, rev=s2, benchmark=b1)
 
         rep = self.make_report(s2)
-        self.assertRegexpMatches(rep.summary, '[sS]pace')
-        self.assertEquals('red', rep.colorcode)
+        self.assertRegex(rep.summary, '[sS]pace')
+        self.assertEqual('red', rep.colorcode)
 
     def make_result(self, value, rev=None, benchmark=None):
         from uuid import uuid4
@@ -280,18 +280,18 @@ def test_github_browsing_url(self):
 
         # It should work with https:// as well as git:// urls
         self.github_project.save()
-        self.assertEquals(self.github_project.commit_browsing_url,
+        self.assertEqual(self.github_project.commit_browsing_url,
                           'https://github.com/tobami/codespeed.git/'
                           'commit/{commitid}')
 
         self.github_project.repo_path = 'git://github.com/tobami/codespeed.git'
         self.github_project.save()
-        self.assertEquals(self.github_project.commit_browsing_url,
+        self.assertEqual(self.github_project.commit_browsing_url,
                           'https://github.com/tobami/codespeed.git/'
                           'commit/{commitid}')
 
         # If filled in, commit browsing url should not change
         self.github_project.commit_browsing_url = 'https://example.com/{commitid}'
         self.github_project.save()
-        self.assertEquals(self.github_project.commit_browsing_url,
+        self.assertEqual(self.github_project.commit_browsing_url,
                           'https://example.com/{commitid}')

codespeed/tests/test_views.py

@@ -36,15 +36,15 @@ def test_add_correct_result(self):
         response = self.client.post(self.path, self.data)
 
         # Check that we get a success response
-        self.assertEquals(response.status_code, 202)
-        self.assertEquals(response.content.decode(), "Result data saved successfully")
+        self.assertEqual(response.status_code, 202)
+        self.assertEqual(response.content.decode(), "Result data saved successfully")
 
         # Check that the data was correctly saved
         e = Environment.objects.get(name='Dual Core')
         b = Benchmark.objects.get(name='float')
-        self.assertEquals(b.benchmark_type, "C")
-        self.assertEquals(b.units, "seconds")
-        self.assertEquals(b.lessisbetter, True)
+        self.assertEqual(b.benchmark_type, "C")
+        self.assertEqual(b.units, "seconds")
+        self.assertEqual(b.lessisbetter, True)
         p = Project.objects.get(name='MyProject')
         branch = Branch.objects.get(name='default', project=p)
         r = Revision.objects.get(commitid='23', branch=branch)
@@ -68,15 +68,15 @@ def test_add_non_default_result(self):
         modified_data['max'] = 2
         modified_data['min'] = 1.0
         response = self.client.post(self.path, modified_data)
-        self.assertEquals(response.status_code, 202)
-        self.assertEquals(response.content.decode(), "Result data saved successfully")
+        self.assertEqual(response.status_code, 202)
+        self.assertEqual(response.content.decode(), "Result data saved successfully")
         e = Environment.objects.get(name='Dual Core')
         p = Project.objects.get(name='MyProject')
         branch = Branch.objects.get(name='default', project=p)
         r = Revision.objects.get(commitid='23', branch=branch)
 
         # Tweak the resolution down to avoid failing over very slight differences:
-        self.assertEquals(r.date, revision_date)
+        self.assertEqual(r.date, revision_date)
 
         i = Executable.objects.get(name='myexe O3 64bits')
         b = Benchmark.objects.get(name='float')
@@ -86,18 +86,18 @@ def test_add_non_default_result(self):
             benchmark=b,
             environment=e
         )
-        self.assertEquals(res.date, result_date)
-        self.assertEquals(res.std_dev, 1.11111)
-        self.assertEquals(res.val_max, 2)
-        self.assertEquals(res.val_min, 1)
+        self.assertEqual(res.date, result_date)
+        self.assertEqual(res.std_dev, 1.11111)
+        self.assertEqual(res.val_max, 2)
+        self.assertEqual(res.val_min, 1)
 
     def test_bad_environment(self):
         """Should return 400 when environment does not exist"""
         bad_name = '10 Core'
         self.data['environment'] = bad_name
         response = self.client.post(self.path, self.data)
-        self.assertEquals(response.status_code, 400)
-        self.assertEquals(response.content.decode(),
+        self.assertEqual(response.status_code, 400)
+        self.assertEqual(response.content.decode(),
                           "Environment " + bad_name + " not found")
         self.data['environment'] = 'Dual Core'
 
@@ -107,8 +107,8 @@ def test_empty_argument(self):
             backup = self.data[key]
             self.data[key] = ""
             response = self.client.post(self.path, self.data)
-            self.assertEquals(response.status_code, 400)
-            self.assertEquals(
+            self.assertEqual(response.status_code, 400)
+            self.assertEqual(
                 response.content.decode(),
                 'Value for key "' + key + '" empty in request')
             self.data[key] = backup
@@ -119,8 +119,8 @@ def test_missing_argument(self):
             backup = self.data[key]
             del(self.data[key])
             response = self.client.post(self.path, self.data)
-            self.assertEquals(response.status_code, 400)
-            self.assertEquals(
+            self.assertEqual(response.status_code, 400)
+            self.assertEqual(
                 response.content.decode(),
                 'Key "' + key + '" missing from request')
             self.data[key] = backup
@@ -130,7 +130,7 @@ def test_report_is_not_created(self):
         self.client.post(self.path, self.data)
         number_of_reports = len(Report.objects.all())
         # After adding one result for one revision, there should be no reports
-        self.assertEquals(number_of_reports, 0)
+        self.assertEqual(number_of_reports, 0)
 
     def test_report_is_created(self):
         """Should create a report when adding a result for two revisions"""
@@ -142,23 +142,23 @@ def test_report_is_created(self):
         # Second result should trigger report creation
         self.client.post(self.path, modified_data)
         number_of_reports = len(Report.objects.all())
-        self.assertEquals(number_of_reports, 1)
+        self.assertEqual(number_of_reports, 1)
 
     def test_submit_data_with_none_timestamp(self):
         """Should add a default revision date when timestamp is None"""
         modified_data = copy.deepcopy(self.data)
         modified_data['revision_date'] = 'None'
         response = self.client.post(self.path, modified_data)
-        self.assertEquals(response.status_code, 202)
+        self.assertEqual(response.status_code, 202)
 
     def test_add_result_with_no_project(self):
         """Should add a revision with the project"""
         modified_data = copy.deepcopy(self.data)
         modified_data['project'] = "My new project"
         modified_data['executable'] = "My new executable"
         response = self.client.post(self.path, modified_data)
-        self.assertEquals(response.status_code, 202)
-        self.assertEquals(
+        self.assertEqual(response.status_code, 202)
+        self.assertEqual(
             response.content.decode(), "Result data saved successfully")
 
 
@@ -209,24 +209,24 @@ def test_get_returns_405(self):
         response = self.client.get(self.path,
                                    {'json': json.dumps(self.data)})
 
-        self.assertEquals(response.status_code, 405)
+        self.assertEqual(response.status_code, 405)
 
     def test_add_correct_results(self):
         """Should add all results when the request data is valid"""
         response = self.client.post(self.path,
                                     {'json': json.dumps(self.data)})
 
         # Check that we get a success response
-        self.assertEquals(response.status_code, 202)
-        self.assertEquals(response.content.decode(),
+        self.assertEqual(response.status_code, 202)
+        self.assertEqual(response.content.decode(),
                           "All result data saved successfully")
 
         # Check that the data was correctly saved
         e = Environment.objects.get(name='bigdog')
         b = Benchmark.objects.get(name='Richards')
-        self.assertEquals(b.benchmark_type, "C")
-        self.assertEquals(b.units, "seconds")
-        self.assertEquals(b.lessisbetter, True)
+        self.assertEqual(b.benchmark_type, "C")
+        self.assertEqual(b.units, "seconds")
+        self.assertEqual(b.lessisbetter, True)
         p = Project.objects.get(name='pypy')
         branch = Branch.objects.get(name='default', project=p)
         r = Revision.objects.get(commitid='123', branch=branch)
@@ -270,8 +270,8 @@ def test_bad_environment(self):
         response = self.client.post(self.path,
                                     {'json': json.dumps(self.data)})
 
-        self.assertEquals(response.status_code, 400)
-        self.assertEquals(
+        self.assertEqual(response.status_code, 400)
+        self.assertEqual(
             response.content.decode(), "Environment " + bad_name + " not found")
         data['environment'] = 'bigdog'
 
@@ -283,8 +283,8 @@ def test_empty_argument(self):
             data[key] = ""
             response = self.client.post(self.path,
                                         {'json': json.dumps(self.data)})
-            self.assertEquals(response.status_code, 400)
-            self.assertEquals(
+            self.assertEqual(response.status_code, 400)
+            self.assertEqual(
                 response.content.decode(),
                 'Value for key "' + key + '" empty in request')
             data[key] = backup
@@ -297,8 +297,8 @@ def test_missing_argument(self):
             del(data[key])
             response = self.client.post(self.path,
                                         {'json': json.dumps(self.data)})
-            self.assertEquals(response.status_code, 400)
-            self.assertEquals(
+            self.assertEqual(response.status_code, 400)
+            self.assertEqual(
                 response.content.decode(), 'Key "' + key + '" missing from request')
             data[key] = backup
 
@@ -309,13 +309,13 @@ def test_report_is_created(self):
                                     {'json': json.dumps(self.data)})
 
         # Check that we get a success response
-        self.assertEquals(response.status_code, 202)
+        self.assertEqual(response.status_code, 202)
 
         number_of_reports = len(Report.objects.all())
         # After adding 4 result for 3 revisions, only 2 reports should be created
         # The third revision will need an extra result for Richards2 in order
         # to trigger report creation
-        self.assertEquals(number_of_reports, 1)
+        self.assertEqual(number_of_reports, 1)
 
 
 class TestTimeline(TestCase):
@@ -325,17 +325,17 @@ def test_fixture(self):
         """Test the loaded fixture data
         """
         env = Environment.objects.filter(name="Dual Core")
-        self.assertEquals(len(env), 1)
+        self.assertEqual(len(env), 1)
         benchmarks = Benchmark.objects.filter(name="float")
-        self.assertEquals(len(benchmarks), 1)
-        self.assertEquals(benchmarks[0].units, "seconds")
+        self.assertEqual(len(benchmarks), 1)
+        self.assertEqual(benchmarks[0].units, "seconds")
         results = benchmarks[0].results.all()
-        self.assertEquals(len(results), 8)
+        self.assertEqual(len(results), 8)
 
     def test_timeline(self):
         path = reverse('timeline')
         response = self.client.get(path)
-        self.assertEquals(response.status_code, 200)
+        self.assertEqual(response.status_code, 200)
         responsedata = response.content.decode()
         self.assertIn("MyProject's Speed Center: Timeline", responsedata)
 
@@ -351,26 +351,26 @@ def test_gettimelinedata(self):
             "revs": "2"
         }
         response = self.client.get(path, data)
-        self.assertEquals(response.status_code, 200)
+        self.assertEqual(response.status_code, 200)
         responsedata = json.loads(response.getvalue().decode())
 
-        self.assertEquals(
+        self.assertEqual(
             responsedata['error'], "None", "there should be no errors")
-        self.assertEquals(
+        self.assertEqual(
             len(responsedata['timelines']), 1, "there should be 1 benchmark")
-        self.assertEquals(
+        self.assertEqual(
             len(responsedata['timelines'][0]['branches']),
             2,
             "there should be 2 branches")
-        self.assertEquals(
+        self.assertEqual(
             len(responsedata['timelines'][0]['branches']['default']),
             1,
             "there should be 1 timeline for master")
-        self.assertEquals(
+        self.assertEqual(
             len(responsedata['timelines'][0]['branches']['master']['1']),
             2,
             "There are 2 datapoints")
-        self.assertEquals(
+        self.assertEqual(
             responsedata['timelines'][0]['branches']['master']['1'][1],
             [u'2011/04/13 17:04:22 ', 2000.0, 1.11111, u'2', u'', u'master'])
 

manage.py

@@ -2,10 +2,7 @@
 import os, sys
 
 if __name__ == "__main__":
-    if 'test' in sys.argv:
-        os.environ.setdefault("DJANGO_SETTINGS_MODULE", "codespeed.tests.settings")
-    else:
-        os.environ.setdefault("DJANGO_SETTINGS_MODULE", "speed_pypy.settings")
+    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "speed_pypy.settings")
 
     from django.core.management import execute_from_command_line
     execute_from_command_line(sys.argv)