Ruff: Fix PTH123 in unittests (exclude unittests/tools) (#12112)

Author: kiblik

ruff.toml

@@ -110,7 +110,9 @@ preview = true
 "unittests/**" = [
     "S105",  # hardcoded passwords in tests are fine
     "S108",  # tmp paths mentioned in tests are fine
-    "PTH123", # Fix is needed in unittests as well but there are too many problematic files, let's do it per partes
+]
+"unittests/tools/**" = [
+    "PTH123", # Fix is needed in unittests/tools as well but there are too many problematic files, let's do it per partes
 ]
 ".github/pr-reminder.py" = [
     "INP001", # https://docs.astral.sh/ruff/rules/implicit-namespace-package/

unittests/dojo_test_case.py

@@ -510,7 +510,7 @@ def import_scan_with_params(self, filename, scan_type="ZAP Scan", engagement=1,
                                 product_name=None, product_type_name=None, auto_create_context=None, expected_http_status_code=201, test_title=None,
                                 scan_date=None, service=None, force_active=True, force_verified=True):
 
-        with open(get_unit_tests_path() / filename, encoding="utf-8") as testfile:
+        with (get_unit_tests_path() / filename).open(encoding="utf-8") as testfile:
             payload = {
                     "minimum_severity": minimum_severity,
                     "active": active,
@@ -562,7 +562,7 @@ def import_scan_with_params(self, filename, scan_type="ZAP Scan", engagement=1,
     def reimport_scan_with_params(self, test_id, filename, scan_type="ZAP Scan", engagement=1, minimum_severity="Low", *, active=True, verified=False, push_to_jira=None,
                                   tags=None, close_old_findings=True, group_by=None, engagement_name=None, scan_date=None,
                                   product_name=None, product_type_name=None, auto_create_context=None, expected_http_status_code=201, test_title=None):
-        with open(filename, encoding="utf-8") as testfile:
+        with Path(filename).open(encoding="utf-8") as testfile:
             payload = {
                     "minimum_severity": minimum_severity,
                     "active": active,
@@ -611,7 +611,7 @@ def reimport_scan_with_params(self, test_id, filename, scan_type="ZAP Scan", eng
     def endpoint_meta_import_scan_with_params(self, filename, product=1, product_name=None, *,
                                               create_endpoints=True, create_tags=True, create_dojo_meta=True,
                                               expected_http_status_code=201):
-        with open(filename, encoding="utf-8") as testfile:
+        with Path(filename).open(encoding="utf-8") as testfile:
             payload = {
                 "create_endpoints": create_endpoints,
                 "create_tags": create_tags,

unittests/test_apiv2_scan_import_options.py

@@ -1,3 +1,5 @@
+from pathlib import Path
+
 from django.core.files.uploadedfile import SimpleUploadedFile
 from django.urls import reverse
 from rest_framework.authtoken.models import Token
@@ -32,7 +34,7 @@ def setUp(self):
         test.save()
 
     def import_zap_scan(self, *, upload_empty_scan=False):
-        with open("tests/zap_sample.xml", encoding="utf-8") as file:
+        with Path("tests/zap_sample.xml").open(encoding="utf-8") as file:
             if upload_empty_scan:
                 tested_file = SimpleUploadedFile("zap_sample.xml", self.EMPTY_ZAP_SCAN.encode("utf-8"))
             else:

unittests/test_endpoint_meta_import.py

@@ -1,4 +1,5 @@
 import logging
+from pathlib import Path
 
 from django.test.client import Client
 from django.urls import reverse
@@ -206,7 +207,7 @@ def endpoint_meta_import_ui(self, product, payload):
 
     def endpoint_meta_import_scan_with_params_ui(self, filename, product=1, *, create_endpoints=True,
                                                  create_tags=True, create_dojo_meta=True, expected_http_status_code=201):
-        with open(filename, encoding="utf-8") as testfile:
+        with Path(filename).open(encoding="utf-8") as testfile:
             payload = {
                 "create_endpoints": create_endpoints,
                 "create_tags": create_tags,

unittests/test_factory.py

@@ -15,25 +15,25 @@ class TestFactory(DojoTestCase):
     def test_get_parser(self):
         with self.subTest(scan_type="Acunetix Scan"):
             scan_type = "Acunetix Scan"
-            testfile = open(get_unit_tests_path() / "scans" / "acunetix" / "one_finding.xml", encoding="utf-8")
+            testfile = (get_unit_tests_path() / "scans" / "acunetix" / "one_finding.xml").open(encoding="utf-8")
             parser = get_parser(scan_type)
             parser.get_findings(testfile, Test())
             testfile.close()
         with self.subTest(scan_type="Anchore Engine Scan"):
             scan_type = "Anchore Engine Scan"
-            testfile = open(get_unit_tests_path() / "scans" / "anchore_engine" / "one_vuln.json", encoding="utf-8")
+            testfile = (get_unit_tests_path() / "scans" / "anchore_engine" / "one_vuln.json").open(encoding="utf-8")
             parser = get_parser(scan_type)
             parser.get_findings(testfile, Test())
             testfile.close()
         with self.subTest(scan_type="Tenable Scan"):
             scan_type = "Tenable Scan"
-            testfile = open(get_unit_tests_path() / "scans" / "tenable/nessus" / "nessus_v_unknown.xml", encoding="utf-8")
+            testfile = (get_unit_tests_path() / "scans" / "tenable/nessus" / "nessus_v_unknown.xml").open(encoding="utf-8")
             parser = get_parser(scan_type)
             parser.get_findings(testfile, Test())
             testfile.close()
         with self.subTest(scan_type="ZAP Scan"):
             scan_type = "ZAP Scan"
-            testfile = open(get_unit_tests_path() / "scans" / "zap" / "some_2.9.0.xml", encoding="utf-8")
+            testfile = (get_unit_tests_path() / "scans" / "zap" / "some_2.9.0.xml").open(encoding="utf-8")
             parser = get_parser(scan_type)
             parser.get_findings(testfile, Test())
             testfile.close()

unittests/test_import_reimport.py

@@ -2,6 +2,7 @@
 
 # from unittest import skip
 import logging
+from pathlib import Path
 
 from django.test import override_settings
 from django.test.client import Client
@@ -1794,7 +1795,7 @@ def import_scan_ui(self, engagement, payload):
         response = self.client_ui.post(reverse("import_scan_results", args=(engagement, )), payload)
 
         test = Test.objects.get(id=response.url.split("/")[-1])
-        # f = open('response.html', 'w+')
+        # f = Path('response.html').open('w+')
         # f.write(str(response.content, 'utf-8'))
         # f.close()
         self.assertEqual(302, response.status_code, response.content[:1000])
@@ -1822,7 +1823,7 @@ def import_scan_with_params_ui(self, filename, scan_type="ZAP Scan", engagement=
         elif not verified:
             verifiedPayload = "force_to_false"
 
-        with open(filename, encoding="utf-8") as testfile:
+        with Path(filename).open(encoding="utf-8") as testfile:
             payload = {
                     "minimum_severity": minimum_severity,
                     "active": activePayload,
@@ -1860,7 +1861,7 @@ def reimport_scan_with_params_ui(self, test_id, filename, scan_type="ZAP Scan",
         if not verified:
             verifiedPayload = "force_to_false"
 
-        with open(filename, encoding="utf-8") as testfile:
+        with Path(filename).open(encoding="utf-8") as testfile:
             payload = {
                     "minimum_severity": minimum_severity,
                     "active": activePayload,

unittests/test_importers_closeold.py

@@ -37,19 +37,19 @@ def test_close_old_same_engagement(self):
             "scan_type": scan_type,
         }
         # Import first test
-        with open(get_unit_tests_scans_path("acunetix") / "many_findings.xml", "r+", encoding="utf-8") as many_findings_scan:
+        with (get_unit_tests_scans_path("acunetix") / "many_findings.xml").open("r+", encoding="utf-8") as many_findings_scan:
             importer = DefaultImporter(close_old_findings=False, **import_options)
             _, _, len_new_findings, len_closed_findings, _, _, _ = importer.process_scan(many_findings_scan)
             self.assertEqual(4, len_new_findings)
             self.assertEqual(0, len_closed_findings)
         # Import same test, should close no findings
-        with open(get_unit_tests_scans_path("acunetix") / "many_findings.xml", "r+", encoding="utf-8") as many_findings_scan:
+        with (get_unit_tests_scans_path("acunetix") / "many_findings.xml").open("r+", encoding="utf-8") as many_findings_scan:
             importer = DefaultImporter(close_old_findings=True, **import_options)
             _, _, len_new_findings, len_closed_findings, _, _, _ = importer.process_scan(many_findings_scan)
             self.assertEqual(4, len_new_findings)
             self.assertEqual(0, len_closed_findings)
         # Import test with only one finding. Remaining findings should close
-        with open(get_unit_tests_scans_path("acunetix") / "one_finding.xml", "r+", encoding="utf-8") as single_finding_scan:
+        with (get_unit_tests_scans_path("acunetix") / "one_finding.xml").open("r+", encoding="utf-8") as single_finding_scan:
             importer = DefaultImporter(close_old_findings=True, **import_options)
             _, _, len_new_findings, len_closed_findings, _, _, _ = importer.process_scan(single_finding_scan)
             self.assertEqual(1, len_new_findings)
@@ -95,19 +95,19 @@ def test_close_old_same_product_scan(self):
             "scan_type": scan_type,
         }
         # Import first test
-        with open(get_unit_tests_scans_path("acunetix") / "many_findings.xml", "r+", encoding="utf-8") as many_findings_scan:
+        with (get_unit_tests_scans_path("acunetix") / "many_findings.xml").open("r+", encoding="utf-8") as many_findings_scan:
             importer = DefaultImporter(engagement=engagement1, close_old_findings=False, **import_options)
             _, _, len_new_findings, len_closed_findings, _, _, _ = importer.process_scan(many_findings_scan)
             self.assertEqual(4, len_new_findings)
             self.assertEqual(0, len_closed_findings)
         # Import same test, should close no findings
-        with open(get_unit_tests_scans_path("acunetix") / "many_findings.xml", "r+", encoding="utf-8") as many_findings_scan:
+        with (get_unit_tests_scans_path("acunetix") / "many_findings.xml").open("r+", encoding="utf-8") as many_findings_scan:
             importer = DefaultImporter(engagement=engagement2, close_old_findings=True, **import_options)
             _, _, len_new_findings, len_closed_findings, _, _, _ = importer.process_scan(many_findings_scan)
             self.assertEqual(4, len_new_findings)
             self.assertEqual(0, len_closed_findings)
         # Import test with only one finding. Remaining findings should close
-        with open(get_unit_tests_scans_path("acunetix") / "one_finding.xml", "r+", encoding="utf-8") as single_finding_scan:
+        with (get_unit_tests_scans_path("acunetix") / "one_finding.xml").open("r+", encoding="utf-8") as single_finding_scan:
             importer = DefaultImporter(engagement=engagement3, close_old_findings=True, **import_options)
             _, _, len_new_findings, len_closed_findings, _, _, _ = importer.process_scan(single_finding_scan)
             self.assertEqual(1, len_new_findings)
@@ -153,20 +153,20 @@ def test_close_old_same_product_scan_matching_with_unique_id_from_tool(self):
             "scan_type": scan_type,
         }
         # Import first test
-        with open(get_unit_tests_scans_path("semgrep") / "close_old_findings_report_line31.json", "r+", encoding="utf-8") as many_findings_scan:
+        with (get_unit_tests_scans_path("semgrep") / "close_old_findings_report_line31.json").open("r+", encoding="utf-8") as many_findings_scan:
             importer = DefaultImporter(engagement=engagement1, close_old_findings=False, **import_options)
             _, _, len_new_findings, len_closed_findings, _, _, _ = importer.process_scan(many_findings_scan)
             self.assertEqual(1, len_new_findings)
             self.assertEqual(0, len_closed_findings)
         # Import separate report with different line number. Before this change, the legacy dedupe algorithm would calculate a different
         # hash code and close of the findings. Now that we are matching on unique ID from tool, we should no close anything, and create one
-        with open(get_unit_tests_scans_path("semgrep") / "close_old_findings_report_second_run_line24.json", "r+", encoding="utf-8") as many_findings_scan:
+        with (get_unit_tests_scans_path("semgrep") / "close_old_findings_report_second_run_line24.json").open("r+", encoding="utf-8") as many_findings_scan:
             importer = DefaultImporter(engagement=engagement2, close_old_findings=True, **import_options)
             _, _, len_new_findings, len_closed_findings, _, _, _ = importer.process_scan(many_findings_scan)
             self.assertEqual(1, len_new_findings)
             self.assertEqual(0, len_closed_findings)
         # This scan has a different unique ID from tool, so we should have one new finding, and one closed finding
-        with open(get_unit_tests_scans_path("semgrep") / "close_old_findings_report_third_run_different_unique_id.json", "r+", encoding="utf-8") as many_findings_scan:
+        with (get_unit_tests_scans_path("semgrep") / "close_old_findings_report_third_run_different_unique_id.json").open("r+", encoding="utf-8") as many_findings_scan:
             importer = DefaultImporter(engagement=engagement3, close_old_findings=True, **import_options)
             _, _, len_new_findings, len_closed_findings, _, _, _ = importer.process_scan(many_findings_scan)
             self.assertEqual(1, len_new_findings)

unittests/test_importers_importer.py

@@ -39,7 +39,7 @@
 
 class TestDojoDefaultImporter(DojoTestCase):
     def test_parse_findings(self):
-        with open(get_unit_tests_path() / "scans" / "acunetix" / "one_finding.xml", encoding="utf-8") as scan:
+        with (get_unit_tests_path() / "scans" / "acunetix" / "one_finding.xml").open(encoding="utf-8") as scan:
             scan_type = "Acunetix Scan"
             user, _created = User.objects.get_or_create(username="admin")
             product_type, _created = Product_Type.objects.get_or_create(name="test")
@@ -80,7 +80,7 @@ def test_parse_findings(self):
                 self.assertIn(finding.numerical_severity, ["S0", "S1", "S2", "S3", "S4"])
 
     def test_import_scan(self):
-        with open(get_unit_tests_path() / "scans" / "sarif" / "spotbugs.sarif", encoding="utf-8") as scan:
+        with (get_unit_tests_path() / "scans" / "sarif" / "spotbugs.sarif").open(encoding="utf-8") as scan:
             scan_type = SarifParser().get_scan_types()[0]  # SARIF format implement the new method
             user, _ = User.objects.get_or_create(username="admin")
             product_type, _ = Product_Type.objects.get_or_create(name="test2")
@@ -114,7 +114,7 @@ def test_import_scan(self):
             self.assertEqual(0, len_closed_findings)
 
     def test_import_scan_without_test_scan_type(self):
-        with open(get_unit_tests_scans_path("gitlab_sast") / "gl-sast-report-1-vuln_v15.json", encoding="utf-8") as scan:
+        with (get_unit_tests_scans_path("gitlab_sast") / "gl-sast-report-1-vuln_v15.json").open(encoding="utf-8") as scan:
             # GitLabSastParser implements get_tests but report has no scanner name
             scan_type = GitlabSastParser().get_scan_types()[0]
             user, _ = User.objects.get_or_create(username="admin")

unittests/test_parsers.py

@@ -85,7 +85,7 @@ def test_file_existence(self):
                 if file.is_file() and file.name != "__pycache__" and file.name != "__init__.py":
                     f_path = Path(basedir) / "dojo" / "tools" / parser_dir.name / file.name
                     read_true = False
-                    with open(f_path, encoding="utf-8") as f:
+                    with f_path.open(encoding="utf-8") as f:
                         i = 0
                         for line in f:
                             if read_true is True: