diff --git a/dojo/fixtures/dojo_testdata.json b/dojo/fixtures/dojo_testdata.json
index d5b2d4f4538..d689b4eba8e 100644
--- a/dojo/fixtures/dojo_testdata.json
+++ b/dojo/fixtures/dojo_testdata.json
@@ -1,4 +1,21 @@
 [
+  {
+    "pk": 1,
+    "model": "dojo.sla_configuration",
+    "fields": {
+      "name": "Default SLA Configuration",
+      "description": "Default SLA configuration for testing",
+      "critical": 7,
+      "enforce_critical": true,
+      "high": 30,
+      "enforce_high": true,
+      "medium": 90,
+      "enforce_medium": true,
+      "low": 120,
+      "enforce_low": false,
+      "restart_sla_on_reactivation": false
+    }
+  },
   {
     "pk": 1,
     "model": "auth.user",
@@ -184,40 +201,40 @@
       "remote_addr": null,
       "timestamp": "2021-10-22T01:24:54.921Z",
       "additional_data": null
-      }
-    },
-    {
-      "model": "auditlog.logentry",
-      "pk": 804,
-      "fields": {
-        "content_type": 28,
-        "object_pk": "2",
-        "object_id": 2,
-        "object_repr": "Internal CRM App",
-        "action": 0,
-        "changes": "{\"product\": [\"None\", \"dojo.Cred_Mapping.None\"], \"product_meta\": [\"None\", \"dojo.DojoMeta.None\"], \"name\": [\"None\", \"Internal CRM App\"], \"description\": [\"None\", \"* New product in development that attempts to follow all best practices\"], \"product_manager\": [\"None\", \"(product_manager)\"], \"technical_contact\": [\"None\", \"(product_manager)\"], \"team_manager\": [\"None\", \"(user2)\"], \"prod_type\": [\"None\", \"Commerce\"], \"id\": [\"None\", \"2\"], \"tid\": [\"None\", \"0\"], \"business_criticality\": [\"None\", \"medium\"], \"platform\": [\"None\", \"web\"], \"lifecycle\": [\"None\", \"construction\"], \"origin\": [\"None\", \"internal\"], \"external_audience\": [\"None\", \"False\"], \"internet_accessible\": [\"None\", \"False\"], \"enable_simple_risk_acceptance\": [\"None\", \"False\"], \"enable_full_risk_acceptance\": [\"None\", \"True\"]}",
-        "actor": null,
-        "remote_addr": null,
-        "timestamp": "2021-10-22T01:24:55.044Z",
-        "additional_data": null
-      }
-    },
-    {
-      "model": "auditlog.logentry",
-      "pk": 805,
-      "fields": {
-        "content_type": 28,
-        "object_pk": "3",
-        "object_id": 3,
-        "object_repr": "Apple Accounting Software",
-        "action": 0,
-        "changes": "{\"product\": [\"None\", \"dojo.Cred_Mapping.None\"], \"product_meta\": [\"None\", \"dojo.DojoMeta.None\"], \"name\": [\"None\", \"Apple Accounting Software\"], \"description\": [\"None\", \"Accounting software is typically composed of various modules, different sections dealing with particular areas of accounting. Among the most common are:\\r\\n\\r\\n**Core modules**\\r\\n\\r\\n* Accounts receivable\\u2014where the company enters money received\\r\\n* Accounts payable\\u2014where the company enters its bills and pays money it owes\\r\\n* General ledger\\u2014the company's \\\"books\\\"\\r\\n* Billing\\u2014where the company produces invoices to clients/customers\"], \"product_manager\": [\"None\", \"(admin)\"], \"technical_contact\": [\"None\", \"(user2)\"], \"team_manager\": [\"None\", \"(user2)\"], \"prod_type\": [\"None\", \"Billing\"], \"id\": [\"None\", \"3\"], \"tid\": [\"None\", \"0\"], \"business_criticality\": [\"None\", \"high\"], \"platform\": [\"None\", \"web\"], \"lifecycle\": [\"None\", \"production\"], \"origin\": [\"None\", \"purchased\"], \"user_records\": [\"None\", \"5000\"], \"external_audience\": [\"None\", \"True\"], \"internet_accessible\": [\"None\", \"False\"], \"enable_simple_risk_acceptance\": [\"None\", \"False\"], \"enable_full_risk_acceptance\": [\"None\", \"True\"]}",
-        "actor": null,
-        "remote_addr": null,
-        "timestamp": "2021-10-22T01:24:55.071Z",
-        "additional_data": null
-      }
-    },
+    }
+  },
+  {
+    "model": "auditlog.logentry",
+    "pk": 804,
+    "fields": {
+      "content_type": 28,
+      "object_pk": "2",
+      "object_id": 2,
+      "object_repr": "Internal CRM App",
+      "action": 0,
+      "changes": "{\"product\": [\"None\", \"dojo.Cred_Mapping.None\"], \"product_meta\": [\"None\", \"dojo.DojoMeta.None\"], \"name\": [\"None\", \"Internal CRM App\"], \"description\": [\"None\", \"* New product in development that attempts to follow all best practices\"], \"product_manager\": [\"None\", \"(product_manager)\"], \"technical_contact\": [\"None\", \"(product_manager)\"], \"team_manager\": [\"None\", \"(user2)\"], \"prod_type\": [\"None\", \"Commerce\"], \"id\": [\"None\", \"2\"], \"tid\": [\"None\", \"0\"], \"business_criticality\": [\"None\", \"medium\"], \"platform\": [\"None\", \"web\"], \"lifecycle\": [\"None\", \"construction\"], \"origin\": [\"None\", \"internal\"], \"external_audience\": [\"None\", \"False\"], \"internet_accessible\": [\"None\", \"False\"], \"enable_simple_risk_acceptance\": [\"None\", \"False\"], \"enable_full_risk_acceptance\": [\"None\", \"True\"]}",
+      "actor": null,
+      "remote_addr": null,
+      "timestamp": "2021-10-22T01:24:55.044Z",
+      "additional_data": null
+    }
+  },
+  {
+    "model": "auditlog.logentry",
+    "pk": 805,
+    "fields": {
+      "content_type": 28,
+      "object_pk": "3",
+      "object_id": 3,
+      "object_repr": "Apple Accounting Software",
+      "action": 0,
+      "changes": "{\"product\": [\"None\", \"dojo.Cred_Mapping.None\"], \"product_meta\": [\"None\", \"dojo.DojoMeta.None\"], \"name\": [\"None\", \"Apple Accounting Software\"], \"description\": [\"None\", \"Accounting software is typically composed of various modules, different sections dealing with particular areas of accounting. Among the most common are:\\r\\n\\r\\n**Core modules**\\r\\n\\r\\n* Accounts receivable\\u2014where the company enters money received\\r\\n* Accounts payable\\u2014where the company enters its bills and pays money it owes\\r\\n* General ledger\\u2014the company's \\\"books\\\"\\r\\n* Billing\\u2014where the company produces invoices to clients/customers\"], \"product_manager\": [\"None\", \"(admin)\"], \"technical_contact\": [\"None\", \"(user2)\"], \"team_manager\": [\"None\", \"(user2)\"], \"prod_type\": [\"None\", \"Billing\"], \"id\": [\"None\", \"3\"], \"tid\": [\"None\", \"0\"], \"business_criticality\": [\"None\", \"high\"], \"platform\": [\"None\", \"web\"], \"lifecycle\": [\"None\", \"production\"], \"origin\": [\"None\", \"purchased\"], \"user_records\": [\"None\", \"5000\"], \"external_audience\": [\"None\", \"True\"], \"internet_accessible\": [\"None\", \"False\"], \"enable_simple_risk_acceptance\": [\"None\", \"False\"], \"enable_full_risk_acceptance\": [\"None\", \"True\"]}",
+      "actor": null,
+      "remote_addr": null,
+      "timestamp": "2021-10-22T01:24:55.071Z",
+      "additional_data": null
+    }
+  },
   {
     "pk": 1,
     "model": "dojo.system_settings",
diff --git a/dojo/importers/default_importer.py b/dojo/importers/default_importer.py
index 726e55717eb..7696ed19c9c 100644
--- a/dojo/importers/default_importer.py
+++ b/dojo/importers/default_importer.py
@@ -40,7 +40,6 @@ def validate_engagement(
 
 
 class DefaultImporter(BaseImporter, DefaultImporterOptions):
-
     """
     The classic importer process used by DefectDojo
 
@@ -89,7 +88,7 @@ def process_scan(
         scan: TemporaryUploadedFile,
         *args: list,
         **kwargs: dict,
-    ) -> tuple[Test, int, int, int, int, int, Test_Import]:
+    ) -> tuple[Test, int, int, int, int, int, Test_Import, dict]:
         """
         The full step process of taking a scan report, and converting it to
         findings in the database. This entails the the following actions:
@@ -150,7 +149,7 @@ def process_scan(
         logger.debug("IMPORT_SCAN: Updating Test progress")
         self.update_test_progress()
         logger.debug("IMPORT_SCAN: Done")
-        return self.test, 0, len(new_findings), len(closed_findings), 0, 0, test_import_history
+        return self.test, 0, len(new_findings), len(closed_findings), 0, 0, test_import_history, {}
 
     def process_findings(
         self,
@@ -178,7 +177,12 @@ def process_findings(
         for raw_finding in parsed_findings or []:
             sanitized = self.sanitize_severity(raw_finding)
             if Finding.SEVERITIES[sanitized.severity] > Finding.SEVERITIES[self.minimum_severity]:
-                logger.debug("skipping finding due to minimum severity filter (finding=%s severity=%s min=%s)", sanitized.title, sanitized.severity, self.minimum_severity)
+                logger.debug(
+                    "skipping finding due to minimum severity filter (finding=%s severity=%s min=%s)",
+                    sanitized.title,
+                    sanitized.severity,
+                    self.minimum_severity,
+                )
                 continue
             cleaned_findings.append(sanitized)
 
@@ -194,7 +198,13 @@ def process_findings(
             unsaved_finding.reporter = self.user
             unsaved_finding.last_reviewed_by = self.user
             unsaved_finding.last_reviewed = self.now
-            logger.debug("process_parsed_finding: unique_id_from_tool: %s, hash_code: %s, active from report: %s, verified from report: %s", unsaved_finding.unique_id_from_tool, unsaved_finding.hash_code, unsaved_finding.active, unsaved_finding.verified)
+            logger.debug(
+                "process_parsed_finding: unique_id_from_tool: %s, hash_code: %s, active from report: %s, verified from report: %s",
+                unsaved_finding.unique_id_from_tool,
+                unsaved_finding.hash_code,
+                unsaved_finding.active,
+                unsaved_finding.verified,
+            )
             # indicates an override. Otherwise, do not change the value of unsaved_finding.active
             if self.active is not None:
                 unsaved_finding.active = self.active
@@ -260,7 +270,7 @@ def process_findings(
                 # Execute task immediately for synchronous processing
                 post_processing_task_signature()
 
-        for (group_name, findings) in group_names_to_findings_dict.items():
+        for group_name, findings in group_names_to_findings_dict.items():
             finding_helper.add_findings_to_auto_group(
                 group_name,
                 findings,
@@ -332,10 +342,7 @@ def close_old_findings(
         if self.deduplication_algorithm == "unique_id_from_tool_or_hash_code":
             old_findings = old_findings.exclude(
                 (Q(hash_code__isnull=False) & Q(hash_code__in=new_hash_codes))
-                | (
-                    Q(unique_id_from_tool__isnull=False)
-                    & Q(unique_id_from_tool__in=new_unique_ids_from_tool)
-                ),
+                | (Q(unique_id_from_tool__isnull=False) & Q(unique_id_from_tool__in=new_unique_ids_from_tool)),
             )
         # Accommodate for product scope or engagement scope
         if self.close_old_findings_product_scope:
@@ -351,16 +358,15 @@ def close_old_findings(
         for old_finding in old_findings:
             self.mitigate_finding(
                 old_finding,
-                (
-                    "This finding has been automatically closed "
-                    "as it is not present anymore in recent scans."
-                ),
+                ("This finding has been automatically closed as it is not present anymore in recent scans."),
                 finding_groups_enabled=self.findings_groups_enabled,
                 product_grading_option=False,
             )
         # push finding groups to jira since we only only want to push whole groups
         if self.findings_groups_enabled and self.push_to_jira:
-            for finding_group in {finding.finding_group for finding in old_findings if finding.finding_group is not None}:
+            for finding_group in {
+                finding.finding_group for finding in old_findings if finding.finding_group is not None
+            }:
                 jira_helper.push_to_jira(finding_group)
 
         # Calculate grade once after all findings have been closed
diff --git a/dojo/importers/default_reimporter.py b/dojo/importers/default_reimporter.py
index a1625a85f33..1260989b4a8 100644
--- a/dojo/importers/default_reimporter.py
+++ b/dojo/importers/default_reimporter.py
@@ -52,13 +52,30 @@ def validate_environment(
 
 
 class DefaultReImporter(BaseImporter, DefaultReImporterOptions):
-
     """
     The classic reimporter process used by DefectDojo
 
     This importer is intended to be used when mitigation of
     vulnerabilities is the ultimate tool for getting a current
     point time view of security of a given product
+
+    Dry Run Mode:
+    -------------
+    When dry_run=True, the importer performs a simulation of the reimport process
+    without making any database changes. This allows users to preview what would
+    happen during a real reimport.
+
+    The dry_run mode uses in-memory tracking to accurately simulate deduplication,
+    including matches between findings within the same scan report. This means that
+    if finding 100 and 101 in the report have the same hash_code, finding 101 will
+    correctly be identified as a duplicate of finding 100, just as in a real import.
+
+    Known Limitations in Dry Run Mode:
+    - Endpoint updates are not simulated
+    - Finding groups are not processed
+    - JIRA integration is skipped
+    - No notifications are sent
+    - Test/engagement timestamps are not updated
     """
 
     def __init__(self, *args, **kwargs):
@@ -69,24 +86,76 @@ def __init__(self, *args, **kwargs):
             **kwargs,
         )
 
+    def _serialize_findings_for_dry_run(self, findings: list, is_new: bool = False) -> list:
+        """
+        Serialize finding objects to dictionaries for dry run response.
+
+        Args:
+            findings: List of Finding objects (saved or unsaved)
+            is_new: Whether these are new findings (not yet in DB)
+
+        Returns:
+            List of dictionaries with finding details
+        """
+        serialized = []
+        for finding in findings:
+            finding_dict = {
+                "title": finding.title,
+                "severity": finding.severity,
+                "description": finding.description if hasattr(finding, "description") else None,
+                "cwe": finding.cwe if hasattr(finding, "cwe") else None,
+                "cve": finding.cve if hasattr(finding, "cve") else None,
+                "cvssv3": finding.cvssv3 if hasattr(finding, "cvssv3") else None,
+                "numerical_severity": finding.numerical_severity if hasattr(finding, "numerical_severity") else None,
+            }
+
+            # Add ID for existing findings
+            if not is_new and hasattr(finding, "id") and finding.id:
+                finding_dict["id"] = finding.id
+
+            # Add additional fields if available
+            if hasattr(finding, "component_name") and finding.component_name:
+                finding_dict["component_name"] = finding.component_name
+            if hasattr(finding, "component_version") and finding.component_version:
+                finding_dict["component_version"] = finding.component_version
+            if hasattr(finding, "file_path") and finding.file_path:
+                finding_dict["file_path"] = finding.file_path
+            if hasattr(finding, "line") and finding.line:
+                finding_dict["line"] = finding.line
+            if hasattr(finding, "unique_id_from_tool") and finding.unique_id_from_tool:
+                finding_dict["unique_id_from_tool"] = finding.unique_id_from_tool
+
+            serialized.append(finding_dict)
+
+        return serialized
+
     def process_scan(
         self,
         scan: TemporaryUploadedFile,
         *args: list,
         **kwargs: dict,
-    ) -> tuple[Test, int, int, int, int, int, Test_Import]:
+    ) -> tuple[Test, int, int, int, int, int, Test_Import, dict]:
         """
         The full step process of taking a scan report, and converting it to
-        findings in the database. This entails the the following actions:
+        findings in the database. This entails the following actions:
         - Verify the API scan configuration (if supplied)
-        - Parser the findings
+        - Parse the findings
         - Process the findings
-        - Update the timestamps on the test
-        - Update/Create import history objects
-        - Send out notifications
-        - Update the test progress
+        - Update the timestamps on the test (skipped in dry_run)
+        - Update/Create import history objects (skipped in dry_run)
+        - Send out notifications (skipped in dry_run)
+        - Update the test progress (skipped in dry_run)
+
+        In dry_run mode, only parsing and matching logic runs, with no database writes.
+
+        Returns:
+            Tuple containing test, counts, test_import, and optional findings_details dict
         """
         logger.debug(f"REIMPORT_SCAN: parameters: {locals()}")
+
+        if self.dry_run:
+            logger.info("REIMPORT_SCAN: Running in dry-run mode - no database changes will be made")
+
         # Validate the Tool_Configuration
         self.verify_tool_configuration_from_test()
         # Fetch the parser based upon the string version of the scan type
@@ -100,47 +169,51 @@ def process_scan(
             reactivated_findings,
             findings_to_mitigate,
             untouched_findings,
+            findings_details,
         ) = self.determine_process_method(parsed_findings, **kwargs)
-        # Close any old findings in the processed list if the the user specified for that
-        # to occur in the form that is then passed to the kwargs
+
+        # Close any old findings in the processed list (skipped in dry_run)
         closed_findings = self.close_old_findings(findings_to_mitigate, **kwargs)
-        # Update the timestamps of the test object by looking at the findings imported
-        logger.debug("REIMPORT_SCAN: Updating test/engagement timestamps")
-        # Update the timestamps of the test object by looking at the findings imported
-        self.update_timestamps()
-        # Update the test meta
-        self.update_test_meta()
-        # Update the test tags
-        self.update_test_tags()
-        # Save the test and engagement for changes to take affect
-        self.test.save()
-        self.test.engagement.save()
-        logger.debug("REIMPORT_SCAN: Updating test tags")
-        # Create a test import history object to record the flags sent to the importer
-        # This operation will return None if the user does not have the import history
-        # feature enabled
-        test_import_history = self.update_import_history(
-            new_findings=new_findings,
-            closed_findings=closed_findings,
-            reactivated_findings=reactivated_findings,
-            untouched_findings=untouched_findings,
-        )
-        # Send out som notifications to the user
-        logger.debug("REIMPORT_SCAN: Generating notifications")
-        updated_count = (
-            len(closed_findings) + len(reactivated_findings) + len(new_findings)
-        )
-        self.notify_scan_added(
-            self.test,
-            updated_count,
-            new_findings=new_findings,
-            findings_reactivated=reactivated_findings,
-            findings_mitigated=closed_findings,
-            findings_untouched=untouched_findings,
-        )
-        # Update the test progress to reflect that the import has completed
-        logger.debug("REIMPORT_SCAN: Updating Test progress")
-        self.update_test_progress()
+
+        # Skip database updates in dry_run mode
+        if not self.dry_run:
+            # Update the timestamps of the test object by looking at the findings imported
+            logger.debug("REIMPORT_SCAN: Updating test/engagement timestamps")
+            self.update_timestamps()
+            # Update the test meta
+            self.update_test_meta()
+            # Update the test tags
+            self.update_test_tags()
+            # Save the test and engagement for changes to take affect
+            self.test.save()
+            self.test.engagement.save()
+
+            # Create a test import history object
+            test_import_history = self.update_import_history(
+                new_findings=new_findings,
+                closed_findings=closed_findings,
+                reactivated_findings=reactivated_findings,
+                untouched_findings=untouched_findings,
+            )
+
+            # Send out notifications to the user
+            logger.debug("REIMPORT_SCAN: Generating notifications")
+            updated_count = len(closed_findings) + len(reactivated_findings) + len(new_findings)
+            self.notify_scan_added(
+                self.test,
+                updated_count,
+                new_findings=new_findings,
+                findings_reactivated=reactivated_findings,
+                findings_mitigated=closed_findings,
+                findings_untouched=untouched_findings,
+            )
+            # Update the test progress to reflect that the import has completed
+            logger.debug("REIMPORT_SCAN: Updating Test progress")
+            self.update_test_progress()
+        else:
+            test_import_history = None
+            updated_count = len(new_findings) + len(reactivated_findings) + len(closed_findings)
+
         logger.debug("REIMPORT_SCAN: Done")
         return (
             self.test,
@@ -150,19 +223,26 @@ def process_scan(
             len(reactivated_findings),
             len(untouched_findings),
             test_import_history,
+            findings_details,
         )
 
     def process_findings(
         self,
         parsed_findings: list[Finding],
         **kwargs: dict,
-    ) -> tuple[list[Finding], list[Finding], list[Finding], list[Finding]]:
+    ) -> tuple[list[Finding], list[Finding], list[Finding], list[Finding], dict]:
         """
-        Saves findings in memory that were parsed from the scan report into the database.
+        Processes findings from the scan report. In normal mode, saves findings to the database.
+        In dry_run mode, only performs matching logic without any database writes.
+
         This process involves first saving associated objects such as endpoints, files,
         vulnerability IDs, and request response pairs. Once all that has been completed,
         the finding may be appended to a new or existing group based upon user selection
-        at import time
+        at import time.
+
+        Returns:
+            Tuple containing (new_findings, reactivated_findings, to_mitigate, untouched, findings_details)
+            - findings_details is a dict populated in dry_run mode with serialized finding information
         """
         self.deduplication_algorithm = self.determine_deduplication_algorithm()
         # Only process findings with the same service value (or None)
@@ -182,14 +262,21 @@ def process_findings(
         self.reactivated_items = []
         self.unchanged_items = []
         self.group_names_to_findings_dict = {}
+        # In dry_run mode, track new findings in-memory to enable proper deduplication
+        # within the same scan report (e.g., if finding 100 and 101 have same hash_code)
+        self.dry_run_new_findings = [] if self.dry_run else None
         # Progressive batching for chord execution
         post_processing_task_signatures = []
         current_batch_number = 1
         max_batch_size = 1024
 
         logger.debug(f"starting reimport of {len(parsed_findings) if parsed_findings else 0} items.")
-        logger.debug("STEP 1: looping over findings from the reimported report and trying to match them to existing findings")
-        deduplicationLogger.debug(f"Algorithm used for matching new findings to existing findings: {self.deduplication_algorithm}")
+        logger.debug(
+            "STEP 1: looping over findings from the reimported report and trying to match them to existing findings"
+        )
+        deduplicationLogger.debug(
+            f"Algorithm used for matching new findings to existing findings: {self.deduplication_algorithm}"
+        )
 
         # Pre-sanitize and filter by minimum severity to avoid loop control pitfalls
         cleaned_findings = []
@@ -228,15 +315,22 @@ def process_findings(
             # Determine how to proceed based on whether matches were found or not
             if matched_findings:
                 existing_finding = matched_findings[0]
-                finding, force_continue = self.process_matched_finding(
-                    unsaved_finding,
-                    existing_finding,
-                )
+                if self.dry_run:
+                    # In dry_run mode, skip database writes and just categorize the finding
+                    finding, force_continue = self.categorize_matched_finding_for_dry_run(
+                        unsaved_finding,
+                        existing_finding,
+                    )
+                else:
+                    finding, force_continue = self.process_matched_finding(
+                        unsaved_finding,
+                        existing_finding,
+                    )
                 # Determine if we should skip the rest of the loop
                 if force_continue:
                     continue
-                # Update endpoints on the existing finding with those on the new finding
-                if finding.dynamic_finding:
+                # Update endpoints on the existing finding with those on the new finding (skip in dry_run)
+                if not self.dry_run and finding.dynamic_finding:
                     logger.debug(
                         "Re-import found an existing dynamic finding for this new "
                         "finding. Checking the status of endpoints",
@@ -247,55 +341,70 @@ def process_findings(
                         self.user,
                     )
             else:
-                finding = self.process_finding_that_was_not_matched(unsaved_finding)
-            # This condition __appears__ to always be true, but am afraid to remove it
-            if finding:
-                # Process the rest of the items on the finding
-                finding = self.finding_post_processing(
-                    finding,
-                    unsaved_finding,
-                )
-                # all data is already saved on the finding, we only need to trigger post processing
-
-                # Execute post-processing task immediately if async, otherwise execute synchronously
-                push_to_jira = self.push_to_jira and (not self.findings_groups_enabled or not self.group_by)
-
-                post_processing_task_signature = finding_helper.post_process_finding_save_signature(
-                    finding,
-                    dedupe_option=True,
-                    rules_option=True,
-                    product_grading_option=False,
-                    issue_updater_option=True,
-                    push_to_jira=push_to_jira,
-                )
-                post_processing_task_signatures.append(post_processing_task_signature)
-
-            # Check if we should launch a chord (batch full or end of findings)
-            if we_want_async(async_user=self.user) and post_processing_task_signatures:
-                post_processing_task_signatures, current_batch_number, _ = self.maybe_launch_post_processing_chord(
-                    post_processing_task_signatures,
-                    current_batch_number,
-                    max_batch_size,
-                    is_final,
-                )
-            else:
-                post_processing_task_signature()
+                if self.dry_run:
+                    # In dry_run mode, just add to new_items without saving
+                    self.new_items.append(unsaved_finding)
+                    # Track in-memory for deduplication within the same scan report
+                    self.dry_run_new_findings.append(unsaved_finding)
+                    finding = unsaved_finding
+                else:
+                    finding = self.process_finding_that_was_not_matched(unsaved_finding)
+
+            # Skip post-processing and database writes in dry_run mode
+            if not self.dry_run:
+                # This condition __appears__ to always be true, but am afraid to remove it
+                if finding:
+                    # Process the rest of the items on the finding
+                    finding = self.finding_post_processing(
+                        finding,
+                        unsaved_finding,
+                    )
+                    # all data is already saved on the finding, we only need to trigger post processing
+
+                    # Execute post-processing task immediately if async, otherwise execute synchronously
+                    push_to_jira = self.push_to_jira and (not self.findings_groups_enabled or not self.group_by)
+
+                    post_processing_task_signature = finding_helper.post_process_finding_save_signature(
+                        finding,
+                        dedupe_option=True,
+                        rules_option=True,
+                        product_grading_option=False,
+                        issue_updater_option=True,
+                        push_to_jira=push_to_jira,
+                    )
+                    post_processing_task_signatures.append(post_processing_task_signature)
+
+                # Check if we should launch a chord (batch full or end of findings)
+                if we_want_async(async_user=self.user) and post_processing_task_signatures:
+                    post_processing_task_signatures, current_batch_number, _ = self.maybe_launch_post_processing_chord(
+                        post_processing_task_signatures,
+                        current_batch_number,
+                        max_batch_size,
+                        is_final,
+                    )
+                else:
+                    post_processing_task_signature()
 
-        self.to_mitigate = (set(self.original_items) - set(self.reactivated_items) - set(self.unchanged_items))
+        self.to_mitigate = set(self.original_items) - set(self.reactivated_items) - set(self.unchanged_items)
         # due to #3958 we can have duplicates inside the same report
         # this could mean that a new finding is created and right after
         # that it is detected as the 'matched existing finding' for a
         # following finding in the same report
         # this means untouched can have this finding inside it,
         # while it is in fact a new finding. So we subtract new_items
-        self.untouched = set(self.unchanged_items) - set(self.to_mitigate) - set(self.new_items) - set(self.reactivated_items)
-        # Process groups
-        self.process_groups_for_all_findings(**kwargs)
+        self.untouched = (
+            set(self.unchanged_items) - set(self.to_mitigate) - set(self.new_items) - set(self.reactivated_items)
+        )
 
-        # Note: All chord batching is now handled within the loop above
+        # Skip database updates in dry_run mode
+        if not self.dry_run:
+            # Process groups
+            self.process_groups_for_all_findings(**kwargs)
 
-        # Synchronous tasks were already executed during processing, just calculate grade
-        perform_product_grading(self.test.engagement.product)
+            # Note: All chord batching is now handled within the loop above
+
+            # Synchronous tasks were already executed during processing, just calculate grade
+            perform_product_grading(self.test.engagement.product)
 
         # Process the results and return them back
         return self.process_results(**kwargs)
@@ -307,11 +416,16 @@ def close_old_findings(
     ) -> list[Finding]:
         """
         Updates the status of findings that were detected as "old" by the reimport
-        process findings methods
+        process findings methods. In dry_run mode, returns the list without making changes.
         """
         # First check if close old findings is desired
         if self.close_old_findings_toggle is False:
             return []
+
+        # In dry_run mode, just return the findings list without making changes
+        if self.dry_run:
+            return list(findings)
+
         logger.debug("REIMPORT_SCAN: Closing findings no longer present in scan report")
         # Determine if pushing to jira or if the finding groups are enabled
         mitigated_findings = []
@@ -375,21 +489,50 @@ def match_new_finding_to_existing_finding(
         self,
         unsaved_finding: Finding,
     ) -> list[Finding]:
-        """Matches a single new finding to N existing findings and then returns those matches"""
+        """
+        Matches a single new finding to N existing findings and returns those matches.
+        In dry_run mode, also checks against in-memory findings to simulate proper deduplication
+        within the same scan report.
+        """
         # This code should match the logic used for deduplication out of the re-import feature.
         # See utils.py deduplicate_* functions
         deduplicationLogger.debug("return findings bases on algorithm: %s", self.deduplication_algorithm)
+
+        # Get matches from database
+        db_matches = self._get_db_matches(unsaved_finding)
+
+        # In dry_run mode, also check in-memory findings from current scan
+        if self.dry_run and self.dry_run_new_findings:
+            in_memory_matches = self._get_in_memory_matches(unsaved_finding)
+            # Combine matches: in-memory findings should come first (they would have lower IDs)
+            if in_memory_matches:
+                deduplicationLogger.debug(f"Found {len(in_memory_matches)} in-memory matches in dry_run mode")
+                # Return in-memory match (simulates what would happen if it was saved)
+                return [in_memory_matches[0]]
+
+        return db_matches
+
+    def _get_db_matches(self, unsaved_finding: Finding) -> list[Finding]:
+        """Get matches from the database based on deduplication algorithm"""
         if self.deduplication_algorithm == "hash_code":
-            return Finding.objects.filter(
-                test=self.test,
-                hash_code=unsaved_finding.hash_code,
-            ).exclude(hash_code=None).order_by("id")
+            return (
+                Finding.objects.filter(
+                    test=self.test,
+                    hash_code=unsaved_finding.hash_code,
+                )
+                .exclude(hash_code=None)
+                .order_by("id")
+            )
         if self.deduplication_algorithm == "unique_id_from_tool":
             deduplicationLogger.debug(f"unique_id_from_tool: {unsaved_finding.unique_id_from_tool}")
-            return Finding.objects.filter(
-                test=self.test,
-                unique_id_from_tool=unsaved_finding.unique_id_from_tool,
-            ).exclude(unique_id_from_tool=None).order_by("id")
+            return (
+                Finding.objects.filter(
+                    test=self.test,
+                    unique_id_from_tool=unsaved_finding.unique_id_from_tool,
+                )
+                .exclude(unique_id_from_tool=None)
+                .order_by("id")
+            )
         if self.deduplication_algorithm == "unique_id_from_tool_or_hash_code":
             deduplicationLogger.debug(f"unique_id_from_tool: {unsaved_finding.unique_id_from_tool}")
             deduplicationLogger.debug(f"hash_code: {unsaved_finding.hash_code}")
@@ -405,15 +548,97 @@ def match_new_finding_to_existing_finding(
             # this is left as is for simplicity.
             # Re-writing the legacy deduplication here would be complicated and counter-productive.
             # If you have use cases going through this section, you're advised to create a deduplication configuration for your parser
-            logger.warning("Legacy reimport. In case of issue, you're advised to create a deduplication configuration in order not to go through this section")
+            logger.warning(
+                "Legacy reimport. In case of issue, you're advised to create a deduplication configuration in order not to go through this section"
+            )
             return Finding.objects.filter(
-                    title__iexact=unsaved_finding.title,
-                    test=self.test,
-                    severity=unsaved_finding.severity,
-                    numerical_severity=Finding.get_numerical_severity(unsaved_finding.severity)).order_by("id")
+                title__iexact=unsaved_finding.title,
+                test=self.test,
+                severity=unsaved_finding.severity,
+                numerical_severity=Finding.get_numerical_severity(unsaved_finding.severity),
+            ).order_by("id")
         logger.error(f'Internal error: unexpected deduplication_algorithm: "{self.deduplication_algorithm}"')
         return None
 
+    def _get_in_memory_matches(self, unsaved_finding: Finding) -> list[Finding]:
+        """
+        Check in-memory findings for matches (used in dry_run mode).
+        This simulates the deduplication that would occur within the same scan report.
+        """
+        matches = []
+        for in_memory_finding in self.dry_run_new_findings:
+            if self.deduplication_algorithm == "hash_code":
+                if in_memory_finding.hash_code and in_memory_finding.hash_code == unsaved_finding.hash_code:
+                    matches.append(in_memory_finding)
+            elif self.deduplication_algorithm == "unique_id_from_tool":
+                if (
+                    in_memory_finding.unique_id_from_tool
+                    and in_memory_finding.unique_id_from_tool == unsaved_finding.unique_id_from_tool
+                ):
+                    matches.append(in_memory_finding)
+            elif self.deduplication_algorithm == "unique_id_from_tool_or_hash_code":
+                if (in_memory_finding.hash_code and in_memory_finding.hash_code == unsaved_finding.hash_code) or (
+                    in_memory_finding.unique_id_from_tool
+                    and in_memory_finding.unique_id_from_tool == unsaved_finding.unique_id_from_tool
+                ):
+                    matches.append(in_memory_finding)
+            elif self.deduplication_algorithm == "legacy":
+                if (
+                    in_memory_finding.title.lower() == unsaved_finding.title.lower()
+                    and in_memory_finding.severity == unsaved_finding.severity
+                ):
+                    matches.append(in_memory_finding)
+        return matches
+
+    def categorize_matched_finding_for_dry_run(
+        self,
+        unsaved_finding: Finding,
+        existing_finding: Finding,
+    ) -> tuple[Finding, bool]:
+        """
+        Categorizes a matched finding for dry_run mode without making any database changes.
+        Determines whether the finding would be reactivated, unchanged, etc.
+
+        Returns:
+            Tuple of (finding, force_continue) where force_continue indicates
+            whether to skip further processing of this finding
+        """
+        # Check if special status (false positive, out of scope, risk accepted)
+        if existing_finding.false_p or existing_finding.out_of_scope or existing_finding.risk_accepted:
+            # Check if statuses match exactly
+            if (
+                existing_finding.false_p == unsaved_finding.false_p
+                and existing_finding.out_of_scope == unsaved_finding.out_of_scope
+                and existing_finding.risk_accepted == unsaved_finding.risk_accepted
+            ):
+                self.unchanged_items.append(existing_finding)
+                return existing_finding, True
+            # Risk accepted and inactive - don't sync status from scanner
+            if existing_finding.risk_accepted and not existing_finding.active:
+                self.unchanged_items.append(existing_finding)
+                return existing_finding, False
+            # Status mismatch but still considered unchanged for dry run purposes
+            self.unchanged_items.append(existing_finding)
+            return existing_finding, False
+
+        # Check if currently mitigated
+        if existing_finding.mitigated and existing_finding.is_mitigated:
+            # Check if new finding is also mitigated
+            if unsaved_finding.is_mitigated:
+                self.unchanged_items.append(existing_finding)
+                return existing_finding, True
+            # Would be reactivated (unless do_not_reactivate is set)
+            if self.do_not_reactivate:
+                self.unchanged_items.append(existing_finding)
+                return existing_finding, True
+            # Would be reactivated
+            self.reactivated_items.append(existing_finding)
+            return existing_finding, False
+
+        # Active finding matched - would remain unchanged
+        self.unchanged_items.append(existing_finding)
+        return existing_finding, False
+
     def process_matched_finding(
         self,
         unsaved_finding: Finding,
@@ -562,9 +787,7 @@ def process_matched_mitigated_finding(
         note = Notes(entry=f"Re-activated by {self.scan_type} re-upload.", author=self.user)
         note.save()
         endpoint_statuses = existing_finding.status_finding.exclude(
-            Q(false_positive=True)
-            | Q(out_of_scope=True)
-            | Q(risk_accepted=True),
+            Q(false_positive=True) | Q(out_of_scope=True) | Q(risk_accepted=True),
         )
         self.endpoint_manager.chunk_endpoints_and_reactivate(endpoint_statuses)
         existing_finding.notes.add(note)
@@ -713,7 +936,7 @@ def process_groups_for_all_findings(
         Add findings to a group that may or may not exist, based upon the users
         selection at import time
         """
-        for (group_name, findings) in self.group_names_to_findings_dict.items():
+        for group_name, findings in self.group_names_to_findings_dict.items():
             finding_helper.add_findings_to_auto_group(
                 group_name,
                 findings,
@@ -729,40 +952,44 @@ def process_groups_for_all_findings(
 
         if self.findings_groups_enabled and self.push_to_jira:
             for finding_group in {
-                    finding.finding_group
-                    for finding in self.reactivated_items + self.unchanged_items
-                    if finding.finding_group is not None and not finding.is_mitigated
+                finding.finding_group
+                for finding in self.reactivated_items + self.unchanged_items
+                if finding.finding_group is not None and not finding.is_mitigated
             }:
                 jira_helper.push_to_jira(finding_group)
 
     def process_results(
         self,
         **kwargs: dict,
-    ) -> tuple[list[Finding], list[Finding], list[Finding], list[Finding]]:
+    ) -> tuple[list[Finding], list[Finding], list[Finding], list[Finding], dict]:
         """
-        Determine how to to return the results based on whether the process was
-        ran asynchronous or not
+        Determine how to return the results based on whether the process was
+        ran asynchronous or not. Also builds findings_details for dry_run mode.
         """
+        # Build findings_details for dry_run mode
+        if self.dry_run:
+            findings_details = {
+                "new_findings": self._serialize_findings_for_dry_run(self.new_items, is_new=True),
+                "reactivated_findings": self._serialize_findings_for_dry_run(self.reactivated_items),
+                "closed_findings": self._serialize_findings_for_dry_run(list(self.to_mitigate)),
+                "untouched_findings": self._serialize_findings_for_dry_run(list(self.untouched)),
+            }
+        else:
+            findings_details = {}
+
         if not kwargs.get("sync"):
-            serialized_new_items = [
-                serialize("json", [finding]) for finding in self.new_items
-            ]
-            serialized_reactivated_items = [
-                serialize("json", [finding]) for finding in self.reactivated_items
-            ]
-            serialized_to_mitigate = [
-                serialize("json", [finding]) for finding in self.to_mitigate
-            ]
-            serialized_untouched = [
-                serialize("json", [finding]) for finding in self.untouched
-            ]
+            serialized_new_items = [serialize("json", [finding]) for finding in self.new_items]
+            serialized_reactivated_items = [serialize("json", [finding]) for finding in self.reactivated_items]
+            serialized_to_mitigate = [serialize("json", [finding]) for finding in self.to_mitigate]
+            serialized_untouched = [serialize("json", [finding]) for finding in self.untouched]
             return (
                 serialized_new_items,
                 serialized_reactivated_items,
                 serialized_to_mitigate,
                 serialized_untouched,
+                findings_details,
             )
-        return self.new_items, self.reactivated_items, self.to_mitigate, self.untouched
+        return self.new_items, self.reactivated_items, self.to_mitigate, self.untouched, findings_details
 
     def calculate_unsaved_finding_hash_code(
         self,
diff --git a/dojo/importers/options.py b/dojo/importers/options.py
index 3b7c624235d..02205dcdb08 100644
--- a/dojo/importers/options.py
+++ b/dojo/importers/options.py
@@ -26,7 +26,6 @@
 
 
 class ImporterOptions:
-
     """
     Converts the supplied kwargs into a class for global mutability
     as well as making it more clear which fields are used in each
@@ -48,7 +47,9 @@ def load_base_options(
         **kwargs: dict,
     ):
         self.active: bool = self.validate_active(*args, **kwargs)
-        self.api_scan_configuration: Product_API_Scan_Configuration | None = self.validate_api_scan_configuration(*args, **kwargs)
+        self.api_scan_configuration: Product_API_Scan_Configuration | None = self.validate_api_scan_configuration(
+            *args, **kwargs
+        )
         self.apply_tags_to_endpoints: bool = self.validate_apply_tags_to_endpoints(*args, **kwargs)
         self.apply_tags_to_findings: bool = self.validate_apply_tags_to_findings(*args, **kwargs)
         self.branch_tag: str = self.validate_branch_tag(*args, **kwargs)
@@ -56,8 +57,11 @@ def load_base_options(
         self.close_old_findings_toggle: bool = self.validate_close_old_findings(*args, **kwargs)
         self.close_old_findings_product_scope: bool = self.validate_close_old_findings_product_scope(*args, **kwargs)
         self.do_not_reactivate: bool = self.validate_do_not_reactivate(*args, **kwargs)
+        self.dry_run: bool = self.validate_dry_run(*args, **kwargs)
         self.commit_hash: str = self.validate_commit_hash(*args, **kwargs)
-        self.create_finding_groups_for_all_findings: bool = self.validate_create_finding_groups_for_all_findings(*args, **kwargs)
+        self.create_finding_groups_for_all_findings: bool = self.validate_create_finding_groups_for_all_findings(
+            *args, **kwargs
+        )
         self.endpoints_to_add: list[Endpoint] | None = self.validate_endpoints_to_add(*args, **kwargs)
         self.engagement: Engagement | None = self.validate_engagement(*args, **kwargs)
         self.environment: Development_Environment | None = self.validate_environment(*args, **kwargs)
@@ -102,6 +106,7 @@ def _compress_decorator(function):
         def inner_compress_function(*args, **kwargs):
             args[0].compress_options()
             return function(*args, **kwargs)
+
         return inner_compress_function
 
     @staticmethod
@@ -110,6 +115,7 @@ def _decompress_decorator(function):
         def inner_decompress_function(*args, **kwargs):
             args[0].decompress_options()
             return function(*args, **kwargs)
+
         return inner_decompress_function
 
     def compress_options(self):
@@ -496,7 +502,7 @@ def validate_scan_date(
             **kwargs,
         )
         # Set an additional flag to indicate an override was made
-        self.scan_date_override = (self.now != value)
+        self.scan_date_override = self.now != value
         # Set the timezones appropriately
         if value is not None and not value.tzinfo:
             value = timezone.make_aware(value)
@@ -608,3 +614,16 @@ def validate_version(
             default="",
             **kwargs,
         )
+
+    def validate_dry_run(
+        self,
+        *args: list,
+        **kwargs: dict,
+    ) -> bool:
+        return self.validate(
+            "dry_run",
+            expected_types=[bool],
+            required=False,
+            default=False,
+            **kwargs,
+        )
diff --git a/unittests/dojo_test_case.py b/unittests/dojo_test_case.py
index 4818dd798ce..b712eac352e 100644
--- a/unittests/dojo_test_case.py
+++ b/unittests/dojo_test_case.py
@@ -64,6 +64,7 @@ def wrapper(*args, **kwargs):
                 System_Settings.objects.update(**{flag_name: not value})
                 # Reinitialize middleware with updated settings as this doesn't happen automatically during django tests
                 DojoSytemSettingsMiddleware.load()
+
         return wrapper
 
     return decorator
@@ -94,7 +95,6 @@ def wrapper(*args, **kwargs):
 
 
 class DojoTestUtilsMixin:
-
     def get_test_admin(self, *args, **kwargs):
         return User.objects.get(username="admin")
 
@@ -111,8 +111,12 @@ def create_product_type(self, name, *args, description="dummy description", **kw
         product_type.save()
         return product_type
 
-    def create_sla_configuration(self, name, *args, description="dummy description", critical=7, high=30, medium=60, low=120, **kwargs):
-        sla_configuration = SLA_Configuration(name=name, description=description, critical=critical, high=high, medium=medium, low=low)
+    def create_sla_configuration(
+        self, name, *args, description="dummy description", critical=7, high=30, medium=60, low=120, **kwargs
+    ):
+        sla_configuration = SLA_Configuration(
+            name=name, description=description, critical=critical, high=high, medium=medium, low=low
+        )
         sla_configuration.save()
         return sla_configuration
 
@@ -138,12 +142,21 @@ def patch_endpoint_api(self, endpoint_id, endpoint_details):
         return response.data
 
     def create_engagement(self, name, product, *args, description=None, **kwargs):
-        engagement = Engagement(name=name, description=description, product=product, target_start=timezone.now(), target_end=timezone.now())
+        engagement = Engagement(
+            name=name, description=description, product=product, target_start=timezone.now(), target_end=timezone.now()
+        )
         engagement.save()
         return engagement
 
     def create_test(self, engagement=None, scan_type=None, title=None, *args, description=None, **kwargs):
-        test = Test(title=title, scan_type=scan_type, engagement=engagement, test_type=Test_Type.objects.get(name=scan_type), target_start=timezone.now(), target_end=timezone.now())
+        test = Test(
+            title=title,
+            scan_type=scan_type,
+            engagement=engagement,
+            test_type=Test_Type.objects.get(name=scan_type),
+            target_start=timezone.now(),
+            target_end=timezone.now(),
+        )
         test.save()
         return test
 
@@ -224,7 +237,6 @@ def get_new_product_with_jira_project_data(self):
             "jira-project-form-product_jira_sla_notification": "on",
             "jira-project-form-custom_fields": "null",
             "sla_configuration": 1,
-
         }
 
     def get_new_product_without_jira_project_data(self):
@@ -257,7 +269,6 @@ def get_product_with_jira_project_data(self, product):
             "jira-project-form-product_jira_sla_notification": "on",
             "jira-project-form-custom_fields": "null",
             "sla_configuration": 1,
-
         }
 
     def get_product_with_jira_project_data2(self, product):
@@ -274,7 +285,6 @@ def get_product_with_jira_project_data2(self, product):
             "jira-project-form-product_jira_sla_notification": "on",
             "jira-project-form-custom_fields": "null",
             "sla_configuration": 1,
-
         }
 
     def get_product_with_empty_jira_project_data(self, product):
@@ -306,7 +316,9 @@ def add_product_jira(self, data, expect_redirect_to=None, *, expect_200=False):
         if not expect_redirect_to and not expect_200:
             expect_redirect_to = "/product/%i"
 
-        response = self.client.post(reverse("new_product"), urlencode(data), content_type="application/x-www-form-urlencoded")
+        response = self.client.post(
+            reverse("new_product"), urlencode(data), content_type="application/x-www-form-urlencoded"
+        )
 
         # logger.debug('after: JIRA_Project last')
         # self.log_model_instance(JIRA_Project.objects.last())
@@ -337,7 +349,9 @@ def set_jira_push_all_issues(self, engagement_or_product):
         jira_project.push_all_issues = True
         jira_project.save()
 
-    def add_product_jira_with_data(self, data, expected_delta_jira_project_db, expect_redirect_to=None, *, expect_200=False):
+    def add_product_jira_with_data(
+        self, data, expected_delta_jira_project_db, expect_redirect_to=None, *, expect_200=False
+    ):
         jira_project_count_before = self.db_jira_project_count()
 
         response = self.add_product_jira(data, expect_redirect_to=expect_redirect_to, expect_200=expect_200)
@@ -346,20 +360,38 @@ def add_product_jira_with_data(self, data, expected_delta_jira_project_db, expec
 
         return response
 
-    def add_product_with_jira_project(self, expected_delta_jira_project_db=0, expect_redirect_to=None, *, expect_200=False):
-        return self.add_product_jira_with_data(self.get_new_product_with_jira_project_data(), expected_delta_jira_project_db, expect_redirect_to=expect_redirect_to, expect_200=expect_200)
-
-    def add_product_without_jira_project(self, expected_delta_jira_project_db=0, expect_redirect_to=None, *, expect_200=False):
+    def add_product_with_jira_project(
+        self, expected_delta_jira_project_db=0, expect_redirect_to=None, *, expect_200=False
+    ):
+        return self.add_product_jira_with_data(
+            self.get_new_product_with_jira_project_data(),
+            expected_delta_jira_project_db,
+            expect_redirect_to=expect_redirect_to,
+            expect_200=expect_200,
+        )
+
+    def add_product_without_jira_project(
+        self, expected_delta_jira_project_db=0, expect_redirect_to=None, *, expect_200=False
+    ):
         logger.debug("adding product without jira project")
-        return self.add_product_jira_with_data(self.get_new_product_without_jira_project_data(), expected_delta_jira_project_db, expect_redirect_to=expect_redirect_to, expect_200=expect_200)
+        return self.add_product_jira_with_data(
+            self.get_new_product_without_jira_project_data(),
+            expected_delta_jira_project_db,
+            expect_redirect_to=expect_redirect_to,
+            expect_200=expect_200,
+        )
 
     def edit_product_jira(self, product, data, expect_redirect_to=None, *, expect_200=False):
-        response = self.client.get(reverse("edit_product", args=(product.id, )))
+        response = self.client.get(reverse("edit_product", args=(product.id,)))
 
         # logger.debug('before: JIRA_Project last')
         # self.log_model_instance(JIRA_Project.objects.last())
 
-        response = self.client.post(reverse("edit_product", args=(product.id, )), urlencode(data), content_type="application/x-www-form-urlencoded")
+        response = self.client.post(
+            reverse("edit_product", args=(product.id,)),
+            urlencode(data),
+            content_type="application/x-www-form-urlencoded",
+        )
         # self.log_model_instance(product)
         # logger.debug('after: JIRA_Project last')
         # self.log_model_instance(JIRA_Project.objects.last())
@@ -372,7 +404,9 @@ def edit_product_jira(self, product, data, expect_redirect_to=None, *, expect_20
             self.assertEqual(response.status_code, 200)
         return response
 
-    def edit_jira_project_for_product_with_data(self, product, data, expected_delta_jira_project_db=0, expect_redirect_to=None, expect_200=None):
+    def edit_jira_project_for_product_with_data(
+        self, product, data, expected_delta_jira_project_db=0, expect_redirect_to=None, expect_200=None
+    ):
         jira_project_count_before = self.db_jira_project_count()
 
         if not expect_redirect_to and not expect_200:
@@ -383,20 +417,43 @@ def edit_jira_project_for_product_with_data(self, product, data, expected_delta_
         self.assertEqual(self.db_jira_project_count(), jira_project_count_before + expected_delta_jira_project_db)
         return response
 
-    def edit_jira_project_for_product(self, product, expected_delta_jira_project_db=0, expect_redirect_to=None, *, expect_200=False):
-        return self.edit_jira_project_for_product_with_data(product, self.get_product_with_jira_project_data(product), expected_delta_jira_project_db, expect_redirect_to=expect_redirect_to, expect_200=expect_200)
-
-    def edit_jira_project_for_product2(self, product, expected_delta_jira_project_db=0, expect_redirect_to=None, *, expect_200=False):
-        return self.edit_jira_project_for_product_with_data(product, self.get_product_with_jira_project_data2(product), expected_delta_jira_project_db, expect_redirect_to=expect_redirect_to, expect_200=expect_200)
-
-    def empty_jira_project_for_product(self, product, expected_delta_jira_project_db=0, expect_redirect_to=None, *, expect_200=False):
+    def edit_jira_project_for_product(
+        self, product, expected_delta_jira_project_db=0, expect_redirect_to=None, *, expect_200=False
+    ):
+        return self.edit_jira_project_for_product_with_data(
+            product,
+            self.get_product_with_jira_project_data(product),
+            expected_delta_jira_project_db,
+            expect_redirect_to=expect_redirect_to,
+            expect_200=expect_200,
+        )
+
+    def edit_jira_project_for_product2(
+        self, product, expected_delta_jira_project_db=0, expect_redirect_to=None, *, expect_200=False
+    ):
+        return self.edit_jira_project_for_product_with_data(
+            product,
+            self.get_product_with_jira_project_data2(product),
+            expected_delta_jira_project_db,
+            expect_redirect_to=expect_redirect_to,
+            expect_200=expect_200,
+        )
+
+    def empty_jira_project_for_product(
+        self, product, expected_delta_jira_project_db=0, expect_redirect_to=None, *, expect_200=False
+    ):
         logger.debug("empty jira project for product")
         jira_project_count_before = self.db_jira_project_count()
 
         if not expect_redirect_to and not expect_200:
             expect_redirect_to = self.get_expected_redirect_product(product)
 
-        response = self.edit_product_jira(product, self.get_product_with_empty_jira_project_data(product), expect_redirect_to=expect_redirect_to, expect_200=expect_200)
+        response = self.edit_product_jira(
+            product,
+            self.get_product_with_empty_jira_project_data(product),
+            expect_redirect_to=expect_redirect_to,
+            expect_200=expect_200,
+        )
 
         self.assertEqual(self.db_jira_project_count(), jira_project_count_before + expected_delta_jira_project_db)
         return response
@@ -478,7 +535,6 @@ def get_latest_model(self, model):
 
 
 class DojoTestCase(TestCase, DojoTestUtilsMixin):
-
     def __init__(self, *args, **kwargs):
         TestCase.__init__(self, *args, **kwargs)
 
@@ -493,7 +549,6 @@ def common_check_finding(self, finding):
 
 
 class DojoAPITestCase(APITestCase, DojoTestUtilsMixin):
-
     def __init__(self, *args, **kwargs):
         APITestCase.__init__(self, *args, **kwargs)
 
@@ -533,17 +588,37 @@ def get_results_by_id(self, results: list, object_id: int) -> dict | None:
                 return item
         return None
 
-    def import_scan_with_params(self, filename, scan_type="ZAP Scan", engagement=1, minimum_severity="Low", *, active=True, verified=False,
-                                push_to_jira=None, endpoint_to_add=None, tags=None, close_old_findings=None, group_by=None, engagement_name=None,
-                                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):
-
+    def import_scan_with_params(
+        self,
+        filename,
+        scan_type="ZAP Scan",
+        engagement=1,
+        minimum_severity="Low",
+        *,
+        active=True,
+        verified=False,
+        push_to_jira=None,
+        endpoint_to_add=None,
+        tags=None,
+        close_old_findings=None,
+        group_by=None,
+        engagement_name=None,
+        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 (get_unit_tests_path() / filename).open(encoding="utf-8") as testfile:
             payload = {
-                    "minimum_severity": minimum_severity,
-                    "scan_type": scan_type,
-                    "file": testfile,
-                    "version": "1.0.1",
+                "minimum_severity": minimum_severity,
+                "scan_type": scan_type,
+                "file": testfile,
+                "version": "1.0.1",
             }
 
             if close_old_findings is not None:
@@ -593,17 +668,38 @@ def import_scan_with_params(self, filename, scan_type="ZAP Scan", engagement=1,
 
             return self.import_scan(payload, expected_http_status_code)
 
-    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=None, group_by=None, engagement_name=None, scan_date=None, service=None,
-                                  product_name=None, product_type_name=None, auto_create_context=None, expected_http_status_code=201, test_title=None):
+    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=None,
+        group_by=None,
+        engagement_name=None,
+        scan_date=None,
+        service=None,
+        product_name=None,
+        product_type_name=None,
+        auto_create_context=None,
+        expected_http_status_code=201,
+        test_title=None,
+        dry_run=None,
+    ):
         with Path(filename).open(encoding="utf-8") as testfile:
             payload = {
-                    "minimum_severity": minimum_severity,
-                    "active": active,
-                    "verified": verified,
-                    "scan_type": scan_type,
-                    "file": testfile,
-                    "version": "1.0.1",
+                "minimum_severity": minimum_severity,
+                "active": active,
+                "verified": verified,
+                "scan_type": scan_type,
+                "file": testfile,
+                "version": "1.0.1",
             }
 
             if close_old_findings is not None:
@@ -645,11 +741,22 @@ def reimport_scan_with_params(self, test_id, filename, scan_type="ZAP Scan", eng
             if service is not None:
                 payload["service"] = service
 
+            if dry_run is not None:
+                payload["dry_run"] = dry_run
+
             return self.reimport_scan(payload, expected_http_status_code=expected_http_status_code)
 
-    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):
+    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 Path(filename).open(encoding="utf-8") as testfile:
             payload = {
                 "create_endpoints": create_endpoints,
@@ -708,7 +815,17 @@ def patch_finding_api(self, finding_id, finding_details, push_to_jira=None):
     def assert_finding_count_json(self, count, findings_content_json):
         self.assertEqual(findings_content_json["count"], count)
 
-    def get_test_findings_api(self, test_id, active=None, verified=None, is_mitigated=None, false_p=None, component_name=None, component_version=None, severity=None):
+    def get_test_findings_api(
+        self,
+        test_id,
+        active=None,
+        verified=None,
+        is_mitigated=None,
+        false_p=None,
+        component_name=None,
+        component_version=None,
+        severity=None,
+    ):
         payload = {"test": test_id}
         if active is not None:
             payload["active"] = active
@@ -807,9 +924,23 @@ def log_finding_summary_json_api(self, findings_content_json=None):
             logger.debug("no findings")
         else:
             for finding in findings_content_json["results"]:
-                logger.debug(str(finding["id"]) + ": " + finding["title"][:5] + ":" + finding["severity"] + ": active: " + str(finding["active"]) + ": verified: " + str(finding["verified"])
-                        + ": is_mitigated: " + str(finding["is_mitigated"]) + ": notes: " + str([n["id"] for n in finding["notes"]])
-                        + ": endpoints: " + str(finding["endpoints"]))
+                logger.debug(
+                    str(finding["id"])
+                    + ": "
+                    + finding["title"][:5]
+                    + ":"
+                    + finding["severity"]
+                    + ": active: "
+                    + str(finding["active"])
+                    + ": verified: "
+                    + str(finding["verified"])
+                    + ": is_mitigated: "
+                    + str(finding["is_mitigated"])
+                    + ": notes: "
+                    + str([n["id"] for n in finding["notes"]])
+                    + ": endpoints: "
+                    + str(finding["endpoints"])
+                )
 
         logger.debug("endpoints")
         for ep in Endpoint.objects.all():
@@ -817,7 +948,9 @@ def log_finding_summary_json_api(self, findings_content_json=None):
 
         logger.debug("endpoint statuses")
         for eps in Endpoint_Status.objects.all():
-            logger.debug(str(eps.id) + ": " + str(eps.endpoint) + ": " + str(eps.endpoint.id) + ": " + str(eps.mitigated))
+            logger.debug(
+                str(eps.id) + ": " + str(eps.endpoint) + ": " + str(eps.endpoint.id) + ": " + str(eps.mitigated)
+            )
 
     def get_product_api(self, product_id):
         response = self.client.get(reverse("product-list") + f"{product_id}/", format="json")
diff --git a/unittests/test_import_reimport.py b/unittests/test_import_reimport.py
index e3130cc7efc..65f3b0d215f 100644
--- a/unittests/test_import_reimport.py
+++ b/unittests/test_import_reimport.py
@@ -52,10 +52,10 @@
 # 4 absent
 # 5 active sev medium
 
+
 # test methods to be used both by API Test and UI Test
 class ImportReimportMixin:
     def __init__(self, *args, **kwargs):
-
         self.zap_sample0_filename = get_unit_tests_scans_path("zap") / "0_zap_sample.xml"
         self.zap_sample1_filename = get_unit_tests_scans_path("zap") / "1_zap_sample_0_and_new_absent.xml"
         self.zap_sample2_filename = get_unit_tests_scans_path("zap") / "2_zap_sample_0_and_new_endpoint.xml"
@@ -67,7 +67,9 @@ def __init__(self, *args, **kwargs):
         self.acunetix_file_name = get_unit_tests_scans_path("acunetix") / "one_finding.xml"
         self.scan_type_acunetix = "Acunetix Scan"
 
-        self.gitlab_dep_scan_components_filename = get_unit_tests_scans_path("gitlab_dep_scan") / "gl-dependency-scanning-report-many-vuln_v15.json"
+        self.gitlab_dep_scan_components_filename = (
+            get_unit_tests_scans_path("gitlab_dep_scan") / "gl-dependency-scanning-report-many-vuln_v15.json"
+        )
         self.scan_type_gtlab_dep_scan = "GitLab Dependency Scanning Report"
 
         self.sonarqube_file_name1 = get_unit_tests_scans_path("sonarqube") / "sonar-6-findings.html"
@@ -75,9 +77,15 @@ def __init__(self, *args, **kwargs):
         self.scan_type_sonarqube_detailed = "SonarQube Scan detailed"
 
         self.veracode_many_findings = get_unit_tests_scans_path("veracode") / "many_findings.xml"
-        self.veracode_same_hash_code_different_unique_id = get_unit_tests_scans_path("veracode") / "many_findings_same_hash_code_different_unique_id.xml"
-        self.veracode_same_unique_id_different_hash_code = get_unit_tests_scans_path("veracode") / "many_findings_same_unique_id_different_hash_code.xml"
-        self.veracode_different_hash_code_different_unique_id = get_unit_tests_scans_path("veracode") / "many_findings_different_hash_code_different_unique_id.xml"
+        self.veracode_same_hash_code_different_unique_id = (
+            get_unit_tests_scans_path("veracode") / "many_findings_same_hash_code_different_unique_id.xml"
+        )
+        self.veracode_same_unique_id_different_hash_code = (
+            get_unit_tests_scans_path("veracode") / "many_findings_same_unique_id_different_hash_code.xml"
+        )
+        self.veracode_different_hash_code_different_unique_id = (
+            get_unit_tests_scans_path("veracode") / "many_findings_different_hash_code_different_unique_id.xml"
+        )
         self.veracode_mitigated_findings = get_unit_tests_scans_path("veracode") / "mitigated_finding.xml"
         self.scan_type_veracode = "Veracode Scan"
 
@@ -102,7 +110,9 @@ def __init__(self, *args, **kwargs):
         self.anchore_grype_file_name = get_unit_tests_scans_path("anchore_grype") / "check_all_fields.json"
         self.anchore_grype_scan_type = "Anchore Grype"
 
-        self.checkmarx_one_open_and_false_positive = get_unit_tests_scans_path("checkmarx_one") / "one-open-one-false-positive.json"
+        self.checkmarx_one_open_and_false_positive = (
+            get_unit_tests_scans_path("checkmarx_one") / "one-open-one-false-positive.json"
+        )
         self.checkmarx_one_two_false_positive = get_unit_tests_scans_path("checkmarx_one") / "two-false-positive.json"
         self.scan_type_checkmarx_one = "Checkmarx One Scan"
 
@@ -210,7 +220,9 @@ def test_import_default_scan_date_parser_not_sets_date(self):
     def test_import_default_scan_date_parser_sets_date(self):
         logger.debug("importing original acunetix xml report")
         with assertTestImportModelsCreated(self, imports=1, affected_findings=1, created=1):
-            import0 = self.import_scan_with_params(self.acunetix_file_name, scan_type=self.scan_type_acunetix, active=False, verified=False)
+            import0 = self.import_scan_with_params(
+                self.acunetix_file_name, scan_type=self.scan_type_acunetix, active=False, verified=False
+            )
 
         test_id = import0["test"]
         findings = self.get_test_findings_api(test_id, active=False, verified=False)
@@ -226,7 +238,9 @@ def test_import_default_scan_date_parser_sets_date(self):
     def test_import_set_scan_date_parser_not_sets_date(self):
         logger.debug("importing original zap xml report")
         with assertTestImportModelsCreated(self, imports=1, affected_findings=4, created=4):
-            import0 = self.import_scan_with_params(self.zap_sample0_filename, active=False, verified=False, scan_date="2006-12-26")
+            import0 = self.import_scan_with_params(
+                self.zap_sample0_filename, active=False, verified=False, scan_date="2006-12-26"
+            )
 
         test_id = import0["test"]
         findings = self.get_test_findings_api(test_id, active=False, verified=False)
@@ -242,7 +256,13 @@ def test_import_set_scan_date_parser_not_sets_date(self):
     def test_import_set_scan_date_parser_sets_date(self):
         logger.debug("importing acunetix xml report with date set by parser")
         with assertTestImportModelsCreated(self, imports=1, affected_findings=1, created=1):
-            import0 = self.import_scan_with_params(self.acunetix_file_name, scan_type=self.scan_type_acunetix, active=False, verified=False, scan_date="2006-12-26")
+            import0 = self.import_scan_with_params(
+                self.acunetix_file_name,
+                scan_type=self.scan_type_acunetix,
+                active=False,
+                verified=False,
+                scan_date="2006-12-26",
+            )
 
         test_id = import0["test"]
         findings = self.get_test_findings_api(test_id, active=False, verified=False)
@@ -292,7 +312,9 @@ def test_import_reimport_no_scan_date_parser_date(self):
         test_id = import0["test"]
 
         # reimport report with 1 extra finding
-        reimport0 = self.reimport_scan_with_params(test_id, self.aws_prowler_file_name_plus_one, scan_type=self.scan_type_aws_prowler)
+        reimport0 = self.reimport_scan_with_params(
+            test_id, self.aws_prowler_file_name_plus_one, scan_type=self.scan_type_aws_prowler
+        )
 
         test_id = reimport0["test"]
 
@@ -310,7 +332,9 @@ def test_import_reimport_scan_date_parser_date(self):
         test_id = import0["test"]
 
         # reimport report with 1 extra finding
-        reimport0 = self.reimport_scan_with_params(test_id, self.aws_prowler_file_name_plus_one, scan_type=self.scan_type_aws_prowler, scan_date="2020-02-02")
+        reimport0 = self.reimport_scan_with_params(
+            test_id, self.aws_prowler_file_name_plus_one, scan_type=self.scan_type_aws_prowler, scan_date="2020-02-02"
+        )
 
         test_id = reimport0["test"]
 
@@ -330,7 +354,9 @@ def test_sonar_detailed_scan_base_active_verified(self):
         notes_count_before = self.db_notes_count()
 
         with assertTestImportModelsCreated(self, imports=1, affected_findings=6, created=6):
-            import0 = self.import_scan_with_params(self.sonarqube_file_name1, scan_type=self.scan_type_sonarqube_detailed)
+            import0 = self.import_scan_with_params(
+                self.sonarqube_file_name1, scan_type=self.scan_type_sonarqube_detailed
+            )
 
         test_id = import0["test"]
         findings = self.get_test_findings_api(test_id)
@@ -370,16 +396,25 @@ def test_veracode_scan_base_active_verified(self):
     def test_import_veracode_reimport_veracode_active_verified_mitigated(self):
         logger.debug("reimporting exact same original veracode mitigated xml report again")
 
-        import_veracode_many_findings = self.import_scan_with_params(self.veracode_mitigated_findings, scan_type=self.scan_type_veracode,
-                                                                     verified=True, force_active=True, force_verified=True)
+        import_veracode_many_findings = self.import_scan_with_params(
+            self.veracode_mitigated_findings,
+            scan_type=self.scan_type_veracode,
+            verified=True,
+            force_active=True,
+            force_verified=True,
+        )
 
         test_id = import_veracode_many_findings["test"]
 
         notes_count_before = self.db_notes_count()
 
         # reimport exact same report
-        with assertTestImportModelsCreated(self, reimports=1, affected_findings=1, created=0, closed=1, reactivated=0, untouched=0):
-            reimport_veracode_mitigated_findings = self.reimport_scan_with_params(test_id, self.veracode_mitigated_findings, scan_type=self.scan_type_veracode)
+        with assertTestImportModelsCreated(
+            self, reimports=1, affected_findings=1, created=0, closed=1, reactivated=0, untouched=0
+        ):
+            reimport_veracode_mitigated_findings = self.reimport_scan_with_params(
+                test_id, self.veracode_mitigated_findings, scan_type=self.scan_type_veracode
+            )
 
         test_id = reimport_veracode_mitigated_findings["test"]
         self.assertEqual(test_id, test_id)
@@ -489,7 +524,9 @@ def test_import_0_reimport_0_active_not_verified(self):
     def test_import_sonar1_reimport_sonar1_active_not_verified(self):
         logger.debug("reimporting exact same original sonar report again, verified=False")
 
-        importsonar1 = self.import_scan_with_params(self.sonarqube_file_name1, scan_type=self.scan_type_sonarqube_detailed)
+        importsonar1 = self.import_scan_with_params(
+            self.sonarqube_file_name1, scan_type=self.scan_type_sonarqube_detailed
+        )
 
         test_id = importsonar1["test"]
 
@@ -497,7 +534,9 @@ def test_import_sonar1_reimport_sonar1_active_not_verified(self):
 
         # reimport exact same report
         with assertTestImportModelsCreated(self, reimports=1, untouched=6):
-            reimportsonar1 = self.reimport_scan_with_params(test_id, self.sonarqube_file_name1, scan_type=self.scan_type_sonarqube_detailed, verified=False)
+            reimportsonar1 = self.reimport_scan_with_params(
+                test_id, self.sonarqube_file_name1, scan_type=self.scan_type_sonarqube_detailed, verified=False
+            )
 
         test_id = reimportsonar1["test"]
         self.assertEqual(test_id, test_id)
@@ -520,21 +559,27 @@ def test_import_sonar1_reimport_sonar1_active_not_verified(self):
     # Test the minimum severity flag
     def test_import_sonar1_measure_minimum_severity_counts(self):
         # Critical
-        response_json = self.import_scan_with_params(self.sonarqube_file_name1, scan_type=self.scan_type_sonarqube_detailed, minimum_severity="Critical")
+        response_json = self.import_scan_with_params(
+            self.sonarqube_file_name1, scan_type=self.scan_type_sonarqube_detailed, minimum_severity="Critical"
+        )
         test_id = response_json["test"]
         # Count all findings
         self.assert_finding_count_json(3, self.get_test_findings_api(test_id))
         self.assert_finding_count_json(3, self.get_test_findings_api(test_id, severity="Critical"))
 
         # High
-        response_json = self.import_scan_with_params(self.sonarqube_file_name1, scan_type=self.scan_type_sonarqube_detailed, minimum_severity="High")
+        response_json = self.import_scan_with_params(
+            self.sonarqube_file_name1, scan_type=self.scan_type_sonarqube_detailed, minimum_severity="High"
+        )
         test_id = response_json["test"]
         # Count all findings
         self.assert_finding_count_json(4, self.get_test_findings_api(test_id))
         self.assert_finding_count_json(1, self.get_test_findings_api(test_id, severity="High"))
 
         # Low
-        response_json = self.import_scan_with_params(self.sonarqube_file_name1, scan_type=self.scan_type_sonarqube_detailed, minimum_severity="Low")
+        response_json = self.import_scan_with_params(
+            self.sonarqube_file_name1, scan_type=self.scan_type_sonarqube_detailed, minimum_severity="Low"
+        )
         test_id = response_json["test"]
         # Count all findings
         self.assert_finding_count_json(6, self.get_test_findings_api(test_id))
@@ -547,7 +592,9 @@ def test_import_sonar1_measure_minimum_severity_counts(self):
     def test_import_veracode_reimport_veracode_active_not_verified(self):
         logger.debug("reimporting exact same original veracode report again, verified=False")
 
-        import_veracode_many_findings = self.import_scan_with_params(self.veracode_many_findings, scan_type=self.scan_type_veracode)
+        import_veracode_many_findings = self.import_scan_with_params(
+            self.veracode_many_findings, scan_type=self.scan_type_veracode
+        )
 
         test_id = import_veracode_many_findings["test"]
 
@@ -555,7 +602,9 @@ def test_import_veracode_reimport_veracode_active_not_verified(self):
 
         # reimport exact same report
         with assertTestImportModelsCreated(self, reimports=1, untouched=4):
-            reimport_veracode_many_findings = self.reimport_scan_with_params(test_id, self.veracode_many_findings, scan_type=self.scan_type_veracode, verified=False)
+            reimport_veracode_many_findings = self.reimport_scan_with_params(
+                test_id, self.veracode_many_findings, scan_type=self.scan_type_veracode, verified=False
+            )
 
         test_id = reimport_veracode_many_findings["test"]
         self.assertEqual(test_id, test_id)
@@ -582,7 +631,9 @@ def test_import_veracode_reimport_veracode_active_not_verified(self):
     def test_import_sonar1_reimport_sonar2(self):
         logger.debug("reimporting same findings except one with a different unique_id_from_tool")
 
-        importsonar1 = self.import_scan_with_params(self.sonarqube_file_name1, scan_type=self.scan_type_sonarqube_detailed)
+        importsonar1 = self.import_scan_with_params(
+            self.sonarqube_file_name1, scan_type=self.scan_type_sonarqube_detailed
+        )
 
         test_id = importsonar1["test"]
 
@@ -590,7 +641,9 @@ def test_import_sonar1_reimport_sonar2(self):
 
         # reimport other report
         with assertTestImportModelsCreated(self, reimports=1, affected_findings=2, created=1, closed=1, untouched=5):
-            reimportsonar1 = self.reimport_scan_with_params(test_id, self.sonarqube_file_name2, scan_type=self.scan_type_sonarqube_detailed, verified=False)
+            reimportsonar1 = self.reimport_scan_with_params(
+                test_id, self.sonarqube_file_name2, scan_type=self.scan_type_sonarqube_detailed, verified=False
+            )
 
         test_id = reimportsonar1["test"]
         self.assertEqual(test_id, test_id)
@@ -620,9 +673,13 @@ def test_import_sonar1_reimport_sonar2(self):
     # - reimport, all findings stay the same, stay active
     # - existing findings with verified is true should stay verified
     def test_import_veracode_reimport_veracode_same_hash_code_different_unique_id(self):
-        logger.debug("reimporting report with one finding having same hash_code but different unique_id_from_tool, verified=False")
+        logger.debug(
+            "reimporting report with one finding having same hash_code but different unique_id_from_tool, verified=False"
+        )
 
-        import_veracode_many_findings = self.import_scan_with_params(self.veracode_many_findings, scan_type=self.scan_type_veracode)
+        import_veracode_many_findings = self.import_scan_with_params(
+            self.veracode_many_findings, scan_type=self.scan_type_veracode
+        )
 
         test_id = import_veracode_many_findings["test"]
 
@@ -630,7 +687,12 @@ def test_import_veracode_reimport_veracode_same_hash_code_different_unique_id(se
 
         # reimport
         with assertTestImportModelsCreated(self, reimports=1, untouched=4):
-            reimport_veracode_many_findings = self.reimport_scan_with_params(test_id, self.veracode_same_hash_code_different_unique_id, scan_type=self.scan_type_veracode, verified=False)
+            reimport_veracode_many_findings = self.reimport_scan_with_params(
+                test_id,
+                self.veracode_same_hash_code_different_unique_id,
+                scan_type=self.scan_type_veracode,
+                verified=False,
+            )
 
         test_id = reimport_veracode_many_findings["test"]
         self.assertEqual(test_id, test_id)
@@ -654,10 +716,16 @@ def test_import_veracode_reimport_veracode_same_hash_code_different_unique_id(se
     # - reimport, all findings stay the same, stay active
     # - existing findings with verified is true should stay verified
     def test_import_veracode_reimport_veracode_same_unique_id_different_hash_code(self):
-        logger.debug("reimporting report with one finding having same unique_id_from_tool but different hash_code, verified=False")
+        logger.debug(
+            "reimporting report with one finding having same unique_id_from_tool but different hash_code, verified=False"
+        )
 
-        with assertTestImportModelsCreated(self, imports=1, created=4, affected_findings=4, closed=0, reactivated=0, untouched=0):
-            import_veracode_many_findings = self.import_scan_with_params(self.veracode_many_findings, scan_type=self.scan_type_veracode)
+        with assertTestImportModelsCreated(
+            self, imports=1, created=4, affected_findings=4, closed=0, reactivated=0, untouched=0
+        ):
+            import_veracode_many_findings = self.import_scan_with_params(
+                self.veracode_many_findings, scan_type=self.scan_type_veracode
+            )
 
         test_id = import_veracode_many_findings["test"]
 
@@ -665,7 +733,12 @@ def test_import_veracode_reimport_veracode_same_unique_id_different_hash_code(se
 
         # reimport
         with assertTestImportModelsCreated(self, reimports=1, untouched=4):
-            reimport_veracode_many_findings = self.reimport_scan_with_params(test_id, self.veracode_same_unique_id_different_hash_code, scan_type=self.scan_type_veracode, verified=False)
+            reimport_veracode_many_findings = self.reimport_scan_with_params(
+                test_id,
+                self.veracode_same_unique_id_different_hash_code,
+                scan_type=self.scan_type_veracode,
+                verified=False,
+            )
 
         test_id = reimport_veracode_many_findings["test"]
         self.assertEqual(test_id, test_id)
@@ -690,9 +763,13 @@ def test_import_veracode_reimport_veracode_same_unique_id_different_hash_code(se
     # - 1 added finding, 1 mitigated finding
     # - existing findings with verified is true should stay verified
     def test_import_veracode_reimport_veracode_different_hash_code_different_unique_id(self):
-        logger.debug("reimporting report with one finding having different hash_code and different unique_id_from_tool, verified=False")
+        logger.debug(
+            "reimporting report with one finding having different hash_code and different unique_id_from_tool, verified=False"
+        )
 
-        import_veracode_many_findings = self.import_scan_with_params(self.veracode_many_findings, scan_type=self.scan_type_veracode)
+        import_veracode_many_findings = self.import_scan_with_params(
+            self.veracode_many_findings, scan_type=self.scan_type_veracode
+        )
 
         test_id = import_veracode_many_findings["test"]
 
@@ -700,7 +777,12 @@ def test_import_veracode_reimport_veracode_different_hash_code_different_unique_
 
         # reimport
         with assertTestImportModelsCreated(self, reimports=1, affected_findings=2, created=1, closed=1, untouched=3):
-            reimport_veracode_many_findings = self.reimport_scan_with_params(test_id, self.veracode_different_hash_code_different_unique_id, scan_type=self.scan_type_veracode, verified=False)
+            reimport_veracode_many_findings = self.reimport_scan_with_params(
+                test_id,
+                self.veracode_different_hash_code_different_unique_id,
+                scan_type=self.scan_type_veracode,
+                verified=False,
+            )
 
         test_id = reimport_veracode_many_findings["test"]
         self.assertEqual(test_id, test_id)
@@ -780,7 +862,9 @@ def test_import_0_reimport_1_active_not_verified(self):
     # - zap1 active, zap4 inactive
     # - zap1 is reactivated but should not have a new sla start date and expiration date
     def test_import_0_reimport_1_active_verified_reimport_0_active_verified_sla_no_restart(self):
-        logger.debug("reimporting updated zap xml report, 1 new finding and 1 no longer present, verified=True and then 0 again")
+        logger.debug(
+            "reimporting updated zap xml report, 1 new finding and 1 no longer present, verified=True and then 0 again"
+        )
 
         import0 = self.import_scan_with_params(self.zap_sample0_filename)
 
@@ -809,7 +893,9 @@ def test_import_0_reimport_1_active_verified_reimport_0_active_verified_sla_no_r
         endpoint_status_count_before_active = self.db_endpoint_status_count(mitigated=False)
         endpoint_status_count_before_mitigated = self.db_endpoint_status_count(mitigated=True)
 
-        with assertTestImportModelsCreated(self, reimports=1, affected_findings=2, closed=1, reactivated=1, untouched=3):
+        with assertTestImportModelsCreated(
+            self, reimports=1, affected_findings=2, closed=1, reactivated=1, untouched=3
+        ):
             self.reimport_scan_with_params(test_id, self.zap_sample0_filename)
 
         test_id = reimport1["test"]
@@ -864,7 +950,9 @@ def test_import_0_reimport_1_active_verified_reimport_0_active_verified_sla_no_r
     def test_import_0_reimport_1_active_verified_reimport_0_active_verified_sla_restart(self, mock_now):
         fake_now = datetime(2025, 7, 1, tzinfo=zoneinfo.ZoneInfo("UTC"))
         mock_now.return_value = fake_now
-        logger.debug("reimporting updated zap xml report, 1 new finding and 1 no longer present, verified=True and then 0 again")
+        logger.debug(
+            "reimporting updated zap xml report, 1 new finding and 1 no longer present, verified=True and then 0 again"
+        )
 
         import0 = self.import_scan_with_params(self.zap_sample0_filename)
 
@@ -897,7 +985,9 @@ def test_import_0_reimport_1_active_verified_reimport_0_active_verified_sla_rest
         endpoint_status_count_before_active = self.db_endpoint_status_count(mitigated=False)
         endpoint_status_count_before_mitigated = self.db_endpoint_status_count(mitigated=True)
 
-        with assertTestImportModelsCreated(self, reimports=1, affected_findings=2, closed=1, reactivated=1, untouched=3):
+        with assertTestImportModelsCreated(
+            self, reimports=1, affected_findings=2, closed=1, reactivated=1, untouched=3
+        ):
             self.reimport_scan_with_params(test_id, self.zap_sample0_filename)
 
         test_id = reimport1["test"]
@@ -1086,7 +1176,9 @@ def test_import_0_reimport_3_active_verified(self):
         # - 2 new findings, 2 new endpoints, 2 + 2 new endpoint statuses active, 3 + 3 endpoint statues mitigated due to zap1+2 closed
         self.assertEqual(finding_count_before + 2, self.db_finding_count())
         self.assertEqual(endpoint_count_before, self.db_endpoint_count())
-        self.assertEqual(endpoint_status_count_before_active + 3 + 3 - 3 - 3, self.db_endpoint_status_count(mitigated=False))
+        self.assertEqual(
+            endpoint_status_count_before_active + 3 + 3 - 3 - 3, self.db_endpoint_status_count(mitigated=False)
+        )
         self.assertEqual(endpoint_status_count_before_mitigated + 2 + 2, self.db_endpoint_status_count(mitigated=True))
 
         # - zap2 and zap5 closed
@@ -1196,7 +1288,9 @@ def test_import_0_reimport_0_anchore_file_path(self):
     # reimport Zap0 and only 1 finding must be active
     # the other 3 findings manually set to active=False must remain False
     def test_import_reimport_keep_false_positive_and_out_of_scope(self):
-        logger.debug("importing zap0 with 4 findings, manually setting 3 findings to active=False, reimporting zap0 must return only 1 finding active=True")
+        logger.debug(
+            "importing zap0 with 4 findings, manually setting 3 findings to active=False, reimporting zap0 must return only 1 finding active=True"
+        )
 
         import0 = self.import_scan_with_params(self.zap_sample0_filename)
         test_id = import0["test"]
@@ -1212,26 +1306,41 @@ def test_import_reimport_keep_false_positive_and_out_of_scope(self):
 
         for finding in active_findings_before["results"]:
             if "Zap1" in finding["title"]:
-                self.patch_finding_api(finding["id"], {"active": False,
-                                                       "verified": False,
-                                                       "false_p": True,
-                                                       "out_of_scope": False,
-                                                       "risk_accepted": False,
-                                                       "is_mitigated": True})
+                self.patch_finding_api(
+                    finding["id"],
+                    {
+                        "active": False,
+                        "verified": False,
+                        "false_p": True,
+                        "out_of_scope": False,
+                        "risk_accepted": False,
+                        "is_mitigated": True,
+                    },
+                )
             elif "Zap2" in finding["title"]:
-                self.patch_finding_api(finding["id"], {"active": False,
-                                                       "verified": False,
-                                                       "false_p": False,
-                                                       "out_of_scope": True,
-                                                       "risk_accepted": False,
-                                                       "is_mitigated": True})
+                self.patch_finding_api(
+                    finding["id"],
+                    {
+                        "active": False,
+                        "verified": False,
+                        "false_p": False,
+                        "out_of_scope": True,
+                        "risk_accepted": False,
+                        "is_mitigated": True,
+                    },
+                )
             elif "Zap3" in finding["title"]:
-                self.patch_finding_api(finding["id"], {"active": False,
-                                                       "verified": False,
-                                                       "false_p": False,
-                                                       "out_of_scope": False,
-                                                       "risk_accepted": True,
-                                                       "is_mitigated": True})
+                self.patch_finding_api(
+                    finding["id"],
+                    {
+                        "active": False,
+                        "verified": False,
+                        "false_p": False,
+                        "out_of_scope": False,
+                        "risk_accepted": True,
+                        "is_mitigated": True,
+                    },
+                )
 
         active_findings_before = self.get_test_findings_api(test_id, active=True)
         self.assert_finding_count_json(1, active_findings_before)
@@ -1297,32 +1406,39 @@ def test_import_reimport_keep_false_positive_and_out_of_scope(self):
     # since a project can have multiples versions (component_version) of the same dependency (component_name),
     # we must consider each finding unique, otherwise we would lose valid information
     def test_import_6_reimport_6_gitlab_dep_scan_component_name_and_version(self):
-
-        import0 = self.import_scan_with_params(self.gitlab_dep_scan_components_filename,
-                                               scan_type=self.scan_type_gtlab_dep_scan,
-                                               minimum_severity="Info")
+        import0 = self.import_scan_with_params(
+            self.gitlab_dep_scan_components_filename, scan_type=self.scan_type_gtlab_dep_scan, minimum_severity="Info"
+        )
         test_id = import0["test"]
         active_findings_before = self.get_test_findings_api(test_id, active=True)
         self.assert_finding_count_json(6, active_findings_before)
 
         with assertTestImportModelsCreated(self, reimports=1, affected_findings=0, created=0, untouched=6):
-            self.reimport_scan_with_params(test_id,
-                                                       self.gitlab_dep_scan_components_filename,
-                                                       scan_type=self.scan_type_gtlab_dep_scan,
-                                                       minimum_severity="Info")
+            self.reimport_scan_with_params(
+                test_id,
+                self.gitlab_dep_scan_components_filename,
+                scan_type=self.scan_type_gtlab_dep_scan,
+                minimum_severity="Info",
+            )
 
         active_findings_after = self.get_test_findings_api(test_id, active=True)
         self.assert_finding_count_json(6, active_findings_after)
 
         count = 0
         for finding in active_findings_after["results"]:
-            if finding["component_version"] == "v0.0.0-20190219172222-a4c6cb3142f2" or finding["component_version"] == "v0.0.0-20190308221718-c2843e01d9a2" or finding["component_version"] == "v0.0.0-20200302210943-78000ba7a073":
+            if (
+                finding["component_version"] == "v0.0.0-20190219172222-a4c6cb3142f2"
+                or finding["component_version"] == "v0.0.0-20190308221718-c2843e01d9a2"
+                or finding["component_version"] == "v0.0.0-20200302210943-78000ba7a073"
+            ):
                 self.assertEqual("CVE-2020-29652: Nil Pointer Dereference", finding["title"])
                 self.assertEqual("CVE-2020-29652", finding["vulnerability_ids"][0]["vulnerability_id"])
                 self.assertEqual("golang.org/x/crypto", finding["component_name"])
                 count += 1
             elif finding["component_version"] == "v0.3.0" or finding["component_version"] == "v0.3.2":
-                self.assertEqual("CVE-2020-14040: Loop With Unreachable Exit Condition (Infinite Loop)", finding["title"])
+                self.assertEqual(
+                    "CVE-2020-14040: Loop With Unreachable Exit Condition (Infinite Loop)", finding["title"]
+                )
                 self.assertEqual("CVE-2020-14040", finding["vulnerability_ids"][0]["vulnerability_id"])
                 self.assertEqual("golang.org/x/text", finding["component_name"])
                 count += 1
@@ -1335,7 +1451,9 @@ def test_import_6_reimport_6_gitlab_dep_scan_component_name_and_version(self):
     def test_import_param_close_old_findings_with_additional_endpoint(self):
         logger.debug("importing clair report with additional endpoint")
         with assertTestImportModelsCreated(self, imports=1, affected_findings=4, created=4):
-            import0 = self.import_scan_with_params(self.clair_few_findings, scan_type=self.scan_type_clair, endpoint_to_add=1)
+            import0 = self.import_scan_with_params(
+                self.clair_few_findings, scan_type=self.scan_type_clair, endpoint_to_add=1
+            )
 
         test_id = import0["test"]
         test = self.get_test(test_id)
@@ -1345,7 +1463,9 @@ def test_import_param_close_old_findings_with_additional_endpoint(self):
         self.assert_finding_count_json(4, findings)
 
         # imported findings should be active in the engagement
-        engagement_findings = Finding.objects.filter(test__engagement_id=1, test__test_type=test.test_type, active=True, is_mitigated=False)
+        engagement_findings = Finding.objects.filter(
+            test__engagement_id=1, test__test_type=test.test_type, active=True, is_mitigated=False
+        )
         self.assertEqual(engagement_findings.count(), 4)
 
         # findings should have only one endpoint, added with endpoint_to_add
@@ -1355,10 +1475,14 @@ def test_import_param_close_old_findings_with_additional_endpoint(self):
 
         # reimport empty report to close old findings
         with assertTestImportModelsCreated(self, imports=1, affected_findings=4, closed=4):
-            self.import_scan_with_params(self.clair_empty, scan_type=self.scan_type_clair, close_old_findings=True, endpoint_to_add=1)
+            self.import_scan_with_params(
+                self.clair_empty, scan_type=self.scan_type_clair, close_old_findings=True, endpoint_to_add=1
+            )
 
         # all findings from import0 should be closed now
-        engagement_findings_count = Finding.objects.filter(test__engagement_id=1, test__test_type=test.test_type, active=True, is_mitigated=False).count()
+        engagement_findings_count = Finding.objects.filter(
+            test__engagement_id=1, test__test_type=test.test_type, active=True, is_mitigated=False
+        ).count()
         self.assertEqual(engagement_findings_count, 0)
 
     # import clair scan, testing:
@@ -1367,7 +1491,9 @@ def test_import_param_close_old_findings_with_additional_endpoint(self):
     def test_import_param_close_old_findings_default_with_additional_endpoint(self):
         logger.debug("importing clair report with additional endpoint")
         with assertTestImportModelsCreated(self, imports=1, affected_findings=4, created=4):
-            import0 = self.import_scan_with_params(self.clair_few_findings, scan_type=self.scan_type_clair, endpoint_to_add=1)
+            import0 = self.import_scan_with_params(
+                self.clair_few_findings, scan_type=self.scan_type_clair, endpoint_to_add=1
+            )
 
         test_id = import0["test"]
         test = self.get_test(test_id)
@@ -1377,7 +1503,9 @@ def test_import_param_close_old_findings_default_with_additional_endpoint(self):
         self.assert_finding_count_json(4, findings)
 
         # imported findings should be active in the engagement
-        engagement_findings = Finding.objects.filter(test__engagement_id=1, test__test_type=test.test_type, active=True, is_mitigated=False)
+        engagement_findings = Finding.objects.filter(
+            test__engagement_id=1, test__test_type=test.test_type, active=True, is_mitigated=False
+        )
         self.assertEqual(engagement_findings.count(), 4)
 
         # findings should have only one endpoint, added with endpoint_to_add
@@ -1390,14 +1518,18 @@ def test_import_param_close_old_findings_default_with_additional_endpoint(self):
             self.import_scan_with_params(self.clair_empty, scan_type=self.scan_type_clair, endpoint_to_add=1)
 
         # all findings from import0 should be closed now
-        engagement_findings_count = Finding.objects.filter(test__engagement_id=1, test__test_type=test.test_type, active=True, is_mitigated=False).count()
+        engagement_findings_count = Finding.objects.filter(
+            test__engagement_id=1, test__test_type=test.test_type, active=True, is_mitigated=False
+        ).count()
         self.assertEqual(engagement_findings_count, 4)
 
     # close_old_findings functionality: second (empty) import should close all findings from the first import when setting the same service
     def test_import_param_close_old_findings_with_same_service(self):
         logger.debug("importing clair report with same service")
         with assertTestImportModelsCreated(self, imports=1, affected_findings=4, created=4):
-            import0 = self.import_scan_with_params(self.clair_few_findings, scan_type=self.scan_type_clair, service="service_1")
+            import0 = self.import_scan_with_params(
+                self.clair_few_findings, scan_type=self.scan_type_clair, service="service_1"
+            )
 
         test_id = import0["test"]
         test = self.get_test(test_id)
@@ -1407,22 +1539,30 @@ def test_import_param_close_old_findings_with_same_service(self):
         self.assert_finding_count_json(4, findings)
 
         # imported findings should be active in the engagement
-        engagement_findings = Finding.objects.filter(test__engagement_id=1, test__test_type=test.test_type, active=True, is_mitigated=False)
+        engagement_findings = Finding.objects.filter(
+            test__engagement_id=1, test__test_type=test.test_type, active=True, is_mitigated=False
+        )
         self.assertEqual(engagement_findings.count(), 4)
 
         # reimport empty report to close old findings
         with assertTestImportModelsCreated(self, imports=1, affected_findings=4, closed=4):
-            self.import_scan_with_params(self.clair_empty, scan_type=self.scan_type_clair, close_old_findings=True, service="service_1")
+            self.import_scan_with_params(
+                self.clair_empty, scan_type=self.scan_type_clair, close_old_findings=True, service="service_1"
+            )
 
         # all findings from import0 should be closed now
-        engagement_findings_count = Finding.objects.filter(test__engagement_id=1, test__test_type=test.test_type, active=True, is_mitigated=False).count()
+        engagement_findings_count = Finding.objects.filter(
+            test__engagement_id=1, test__test_type=test.test_type, active=True, is_mitigated=False
+        ).count()
         self.assertEqual(engagement_findings_count, 0)
 
     # close_old_findings functionality: second (empty) import should not close findings from the first import when setting different services
     def test_import_param_close_old_findings_with_different_services(self):
         logger.debug("importing clair report with different services")
         with assertTestImportModelsCreated(self, imports=1, affected_findings=4, created=4):
-            import0 = self.import_scan_with_params(self.clair_few_findings, scan_type=self.scan_type_clair, service="service_1")
+            import0 = self.import_scan_with_params(
+                self.clair_few_findings, scan_type=self.scan_type_clair, service="service_1"
+            )
 
         test_id = import0["test"]
         test = self.get_test(test_id)
@@ -1432,21 +1572,29 @@ def test_import_param_close_old_findings_with_different_services(self):
         self.assert_finding_count_json(4, findings)
 
         # imported findings should be active in the engagement
-        engagement_findings = Finding.objects.filter(test__engagement_id=1, test__test_type=test.test_type, active=True, is_mitigated=False)
+        engagement_findings = Finding.objects.filter(
+            test__engagement_id=1, test__test_type=test.test_type, active=True, is_mitigated=False
+        )
         self.assertEqual(engagement_findings.count(), 4)
 
         # reimport empty report to close old findings
         with assertTestImportModelsCreated(self, imports=1, affected_findings=0, closed=0):
-            self.import_scan_with_params(self.clair_empty, scan_type=self.scan_type_clair, close_old_findings=True, service="service_2")
+            self.import_scan_with_params(
+                self.clair_empty, scan_type=self.scan_type_clair, close_old_findings=True, service="service_2"
+            )
 
         # no findings from import0 should be closed now
-        engagement_findings_count = Finding.objects.filter(test__engagement_id=1, test__test_type=test.test_type, active=True, is_mitigated=False).count()
+        engagement_findings_count = Finding.objects.filter(
+            test__engagement_id=1, test__test_type=test.test_type, active=True, is_mitigated=False
+        ).count()
         self.assertEqual(engagement_findings_count, 4)
 
     # close_old_findings functionality: second (empty) import should not close findings from the first import when setting a service in the first import but none in the second import
     def test_import_param_close_old_findings_with_and_without_service_1(self):
         with assertTestImportModelsCreated(self, imports=1, affected_findings=4, created=4):
-            import0 = self.import_scan_with_params(self.clair_few_findings, scan_type=self.scan_type_clair, service="service_1")
+            import0 = self.import_scan_with_params(
+                self.clair_few_findings, scan_type=self.scan_type_clair, service="service_1"
+            )
 
         test_id = import0["test"]
         test = self.get_test(test_id)
@@ -1456,21 +1604,29 @@ def test_import_param_close_old_findings_with_and_without_service_1(self):
         self.assert_finding_count_json(4, findings)
 
         # imported findings should be active in the engagement
-        engagement_findings = Finding.objects.filter(test__engagement_id=1, test__test_type=test.test_type, active=True, is_mitigated=False)
+        engagement_findings = Finding.objects.filter(
+            test__engagement_id=1, test__test_type=test.test_type, active=True, is_mitigated=False
+        )
         self.assertEqual(engagement_findings.count(), 4)
 
         # reimport empty report to close old findings
         with assertTestImportModelsCreated(self, imports=1, affected_findings=0, closed=0):
-            self.import_scan_with_params(self.clair_empty, scan_type=self.scan_type_clair, close_old_findings=True, service=None)
+            self.import_scan_with_params(
+                self.clair_empty, scan_type=self.scan_type_clair, close_old_findings=True, service=None
+            )
 
         # no findings from import0 should be closed now
-        engagement_findings_count = Finding.objects.filter(test__engagement_id=1, test__test_type=test.test_type, active=True, is_mitigated=False).count()
+        engagement_findings_count = Finding.objects.filter(
+            test__engagement_id=1, test__test_type=test.test_type, active=True, is_mitigated=False
+        ).count()
         self.assertEqual(engagement_findings_count, 4)
 
     # close_old_findings functionality: second (empty) import should not close findings from the first import when setting no service in the first import but one in the second import
     def test_import_param_close_old_findings_with_and_without_service_2(self):
         with assertTestImportModelsCreated(self, imports=1, affected_findings=4, created=4):
-            import0 = self.import_scan_with_params(self.clair_few_findings, scan_type=self.scan_type_clair, close_old_findings=True, service=None)
+            import0 = self.import_scan_with_params(
+                self.clair_few_findings, scan_type=self.scan_type_clair, close_old_findings=True, service=None
+            )
 
         test_id = import0["test"]
         test = self.get_test(test_id)
@@ -1480,22 +1636,30 @@ def test_import_param_close_old_findings_with_and_without_service_2(self):
         self.assert_finding_count_json(4, findings)
 
         # imported findings should be active in the engagement
-        engagement_findings = Finding.objects.filter(test__engagement_id=1, test__test_type=test.test_type, active=True, is_mitigated=False)
+        engagement_findings = Finding.objects.filter(
+            test__engagement_id=1, test__test_type=test.test_type, active=True, is_mitigated=False
+        )
         self.assertEqual(engagement_findings.count(), 4)
 
         # reimport empty report
         with assertTestImportModelsCreated(self, imports=1, affected_findings=0, closed=0):
-            self.import_scan_with_params(self.clair_empty, scan_type=self.scan_type_clair, close_old_findings=True, service="service_2")
+            self.import_scan_with_params(
+                self.clair_empty, scan_type=self.scan_type_clair, close_old_findings=True, service="service_2"
+            )
 
         # no findings from import0 should be closed now
-        engagement_findings_count = Finding.objects.filter(test__engagement_id=1, test__test_type=test.test_type, active=True, is_mitigated=False).count()
+        engagement_findings_count = Finding.objects.filter(
+            test__engagement_id=1, test__test_type=test.test_type, active=True, is_mitigated=False
+        ).count()
         self.assertEqual(engagement_findings_count, 4)
 
     # close_old_findings functionality: second import to different engagement with different service should not close findings from the first engagement
     def test_reimport_close_old_findings_different_engagements_different_services(self):
         logger.debug("importing clair report with service A into engagement 1")
         with assertTestImportModelsCreated(self, imports=1, affected_findings=4, created=4):
-            import1 = self.import_scan_with_params(self.clair_few_findings, scan_type=self.scan_type_clair, engagement=1, service="service_A")
+            import1 = self.import_scan_with_params(
+                self.clair_few_findings, scan_type=self.scan_type_clair, engagement=1, service="service_A"
+            )
 
         test_id = import1["test"]
         test = self.get_test(test_id)
@@ -1505,15 +1669,23 @@ def test_reimport_close_old_findings_different_engagements_different_services(se
         self.assert_finding_count_json(4, findings)
 
         # imported findings should be active in engagement 1
-        engagement1_findings = Finding.objects.filter(test__engagement_id=1, test__test_type=test.test_type, active=True, is_mitigated=False)
+        engagement1_findings = Finding.objects.filter(
+            test__engagement_id=1, test__test_type=test.test_type, active=True, is_mitigated=False
+        )
         self.assertEqual(engagement1_findings.count(), 4)
 
         # reimporting the same report into the same test with a different service should not close any findings and create 4 new findings
-        self.reimport_scan_with_params(test_id, self.clair_few_findings, scan_type=self.scan_type_clair, service="service_B")
+        self.reimport_scan_with_params(
+            test_id, self.clair_few_findings, scan_type=self.scan_type_clair, service="service_B"
+        )
 
-        engagement1_active_finding_count = Finding.objects.filter(test__engagement_id=1, test__test_type=test.test_type, active=True, is_mitigated=False)
+        engagement1_active_finding_count = Finding.objects.filter(
+            test__engagement_id=1, test__test_type=test.test_type, active=True, is_mitigated=False
+        )
         self.assertEqual(engagement1_active_finding_count.count(), 8)
-        engagement1_mitigated_finding_count = Finding.objects.filter(test__engagement_id=1, test__test_type=test.test_type, active=False, is_mitigated=True)
+        engagement1_mitigated_finding_count = Finding.objects.filter(
+            test__engagement_id=1, test__test_type=test.test_type, active=False, is_mitigated=True
+        )
         self.assertEqual(engagement1_mitigated_finding_count.count(), 0)
         # verify findings from engagement 1 are still the same (not mitigated/closed)
         for finding in engagement1_active_finding_count:
@@ -1523,9 +1695,13 @@ def test_reimport_close_old_findings_different_engagements_different_services(se
         # reimporting an empty report with service A should close all findings from the first import, but not the reimported ones with service B
         self.reimport_scan_with_params(test_id, self.clair_empty, scan_type=self.scan_type_clair, service="service_A")
 
-        engagement1_active_finding_count = Finding.objects.filter(test__engagement_id=1, test__test_type=test.test_type, active=True, is_mitigated=False)
+        engagement1_active_finding_count = Finding.objects.filter(
+            test__engagement_id=1, test__test_type=test.test_type, active=True, is_mitigated=False
+        )
         self.assertEqual(engagement1_active_finding_count.count(), 4)
-        engagement1_mitigated_finding_count = Finding.objects.filter(test__engagement_id=1, test__test_type=test.test_type, active=False, is_mitigated=True)
+        engagement1_mitigated_finding_count = Finding.objects.filter(
+            test__engagement_id=1, test__test_type=test.test_type, active=False, is_mitigated=True
+        )
         self.assertEqual(engagement1_mitigated_finding_count.count(), 4)
 
         for finding in engagement1_active_finding_count:
@@ -1541,9 +1717,13 @@ def test_reimport_close_old_findings_different_engagements_different_services(se
         # reimporting an empty report with service B should close all findings from the second  import, and not reopen any findings
         self.reimport_scan_with_params(test_id, self.clair_empty, scan_type=self.scan_type_clair, service="service_B")
 
-        engagement1_active_finding_count = Finding.objects.filter(test__engagement_id=1, test__test_type=test.test_type, active=True, is_mitigated=False)
+        engagement1_active_finding_count = Finding.objects.filter(
+            test__engagement_id=1, test__test_type=test.test_type, active=True, is_mitigated=False
+        )
         self.assertEqual(engagement1_active_finding_count.count(), 0)
-        engagement1_mitigated_finding_count = Finding.objects.filter(test__engagement_id=1, test__test_type=test.test_type, active=False, is_mitigated=True)
+        engagement1_mitigated_finding_count = Finding.objects.filter(
+            test__engagement_id=1, test__test_type=test.test_type, active=False, is_mitigated=True
+        )
         self.assertEqual(engagement1_mitigated_finding_count.count(), 8)
 
         for finding in engagement1_mitigated_finding_count:
@@ -1551,11 +1731,17 @@ def test_reimport_close_old_findings_different_engagements_different_services(se
             self.assertTrue(finding.is_mitigated)
 
         # reimporting a report with findings and service A should reopen the 4findings with service_A but leave the findings with service_B closed.
-        self.reimport_scan_with_params(test_id, self.clair_few_findings, scan_type=self.scan_type_clair, service="service_A")
+        self.reimport_scan_with_params(
+            test_id, self.clair_few_findings, scan_type=self.scan_type_clair, service="service_A"
+        )
 
-        engagement1_active_finding_count = Finding.objects.filter(test__engagement_id=1, test__test_type=test.test_type, active=True, is_mitigated=False)
+        engagement1_active_finding_count = Finding.objects.filter(
+            test__engagement_id=1, test__test_type=test.test_type, active=True, is_mitigated=False
+        )
         self.assertEqual(engagement1_active_finding_count.count(), 4)
-        engagement1_mitigated_finding_count = Finding.objects.filter(test__engagement_id=1, test__test_type=test.test_type, active=False, is_mitigated=True)
+        engagement1_mitigated_finding_count = Finding.objects.filter(
+            test__engagement_id=1, test__test_type=test.test_type, active=False, is_mitigated=True
+        )
         self.assertEqual(engagement1_mitigated_finding_count.count(), 4)
 
         for finding in engagement1_active_finding_count:
@@ -1580,7 +1766,9 @@ def test_import_reimport_generic(self):
 
         # reimport exact same report
         with assertTestImportModelsCreated(self, reimports=1, untouched=1):
-            reimport0 = self.reimport_scan_with_params(test_id, self.generic_filename_with_file, scan_type="Generic Findings Import")
+            reimport0 = self.reimport_scan_with_params(
+                test_id, self.generic_filename_with_file, scan_type="Generic Findings Import"
+            )
 
         test_id2 = reimport0["test"]
         self.assertEqual(test_id, test_id2)
@@ -1619,10 +1807,9 @@ def test_import_reimport_endpoint_where_eps_date_is_different(self):
         endpoint_status_count_before_mitigated = self.db_endpoint_status_count(mitigated=True)
 
         with assertTestImportModelsCreated(self, imports=1, affected_findings=1, created=1):
-            import0 = self.import_scan_with_params(self.gitlab_dast_file_name,
-                                                   self.scan_type_gitlab_dast,
-                                                   active=True,
-                                                   verified=True)
+            import0 = self.import_scan_with_params(
+                self.gitlab_dast_file_name, self.scan_type_gitlab_dast, active=True, verified=True
+            )
 
         test_id = import0["test"]
 
@@ -1640,9 +1827,9 @@ def test_import_reimport_endpoint_where_eps_date_is_different(self):
         self.assertEqual(endpoint_status_count_before_active + 1, self.db_endpoint_status_count(mitigated=False))
         self.assertEqual(endpoint_status_count_before_mitigated, self.db_endpoint_status_count(mitigated=True))
 
-        reimport0 = self.reimport_scan_with_params(test_id,
-                                                   self.gitlab_dast_file_name,
-                                                   scan_type=self.scan_type_gitlab_dast)
+        reimport0 = self.reimport_scan_with_params(
+            test_id, self.gitlab_dast_file_name, scan_type=self.scan_type_gitlab_dast
+        )
         test_id = reimport0["test"]
 
         findings = self.get_test_findings_api(test_id)
@@ -1661,7 +1848,6 @@ def test_import_reimport_endpoint_where_eps_date_is_different(self):
 
     # test handling of vulnerability ids with import
     def test_import_reimport_vulnerability_ids(self):
-
         import0 = self.import_scan_with_params(self.anchore_grype_file_name, scan_type=self.anchore_grype_scan_type)
 
         test_id = import0["test"]
@@ -1683,7 +1869,9 @@ def test_import_reimport_vulnerability_ids(self):
         )
         reimport_test.save()
 
-        self.reimport_scan_with_params(reimport_test.id, self.anchore_grype_file_name, scan_type=self.anchore_grype_scan_type)
+        self.reimport_scan_with_params(
+            reimport_test.id, self.anchore_grype_file_name, scan_type=self.anchore_grype_scan_type
+        )
         findings = Finding.objects.filter(test=reimport_test)
         self.assertEqual(4, len(findings))
         self.assertEqual("GHSA-v6rh-hp5x-86rv", findings[3].cve)
@@ -1720,7 +1908,12 @@ def test_dynamic_parsing_field_set_to_false(self):
 
     def test_false_positive_status_applied_after_reimport(self):
         # Test that checkmarx one with a file that has one open finding, and one false positive finding
-        import0 = self.import_scan_with_params(self.checkmarx_one_open_and_false_positive, scan_type=self.scan_type_checkmarx_one, active=None, verified=None)
+        import0 = self.import_scan_with_params(
+            self.checkmarx_one_open_and_false_positive,
+            scan_type=self.scan_type_checkmarx_one,
+            active=None,
+            verified=None,
+        )
         test_id = import0["test"]
         active_finding_before = self.get_test_findings_api(test_id, active=True)
         false_p_finding_before = self.get_test_findings_api(test_id, false_p=True)
@@ -1728,13 +1921,150 @@ def test_false_positive_status_applied_after_reimport(self):
         self.assertEqual(1, active_finding_before.get("count", 0))
         self.assertEqual(1, false_p_finding_before.get("count", 0))
         # reimport the next report that sets the active finding to false positive
-        self.reimport_scan_with_params(test_id, self.checkmarx_one_two_false_positive, scan_type=self.scan_type_checkmarx_one)
+        self.reimport_scan_with_params(
+            test_id, self.checkmarx_one_two_false_positive, scan_type=self.scan_type_checkmarx_one
+        )
         active_finding_after = self.get_test_findings_api(test_id, active=True)
         false_p_finding_after = self.get_test_findings_api(test_id, false_p=True)
         # Make sure we get the expeceted results
         self.assertEqual(0, active_finding_after.get("count", 0))
         self.assertEqual(2, false_p_finding_after.get("count", 0))
 
+    # Dry run tests
+    def test_dry_run_basic_reimport_analysis(self):
+        """Test that dry_run provides analysis without making database changes"""
+        logger.debug("Testing basic dry_run reimport analysis")
+
+        # Import initial scan
+        with assertTestImportModelsCreated(self, imports=1, affected_findings=4, created=4):
+            import0 = self.import_scan_with_params(self.zap_sample0_filename)
+
+        test_id = import0["test"]
+
+        # Get initial findings count
+        initial_findings = self.get_test_findings_api(test_id)
+        initial_count = len(initial_findings["results"])
+
+        # Perform dry run reimport with different scan
+        dry_run_result = self.reimport_scan_with_params(
+            test_id, self.zap_sample1_filename, dry_run=True, expected_http_status_code=201
+        )
+
+        # Verify dry_run response structure
+        self.assertTrue(dry_run_result.get("dry_run", False), "Response should indicate dry_run mode")
+        self.assertIn("changes_preview", dry_run_result, "Should include changes preview")
+
+        changes = dry_run_result["changes_preview"]
+        expected_fields = ["would_create", "would_reactivate", "would_close", "would_leave_untouched", "total_changes"]
+        for field in expected_fields:
+            self.assertIn(field, changes, f"changes_preview should contain {field}")
+            self.assertIsInstance(changes[field], int, f"{field} should be an integer")
+
+        # Verify no actual database changes occurred
+        post_dry_run_findings = self.get_test_findings_api(test_id)
+        post_dry_run_count = len(post_dry_run_findings["results"])
+
+        self.assertEqual(initial_count, post_dry_run_count, "Dry run should not change findings count")
+
+    def test_dry_run_with_close_old_findings(self):
+        """Test dry_run correctly predicts closing behavior"""
+        logger.debug("Testing dry_run with close_old_findings parameter")
+
+        # Import initial scan
+        with assertTestImportModelsCreated(self, imports=1, affected_findings=4, created=4):
+            import0 = self.import_scan_with_params(self.zap_sample0_filename)
+
+        test_id = import0["test"]
+
+        # Test dry run with close_old_findings=True
+        dry_run_close_true = self.reimport_scan_with_params(
+            test_id, self.zap_sample1_filename, close_old_findings=True, dry_run=True, expected_http_status_code=201
+        )
+
+        changes_close_true = dry_run_close_true["changes_preview"]
+
+        # Test dry run with close_old_findings=False
+        dry_run_close_false = self.reimport_scan_with_params(
+            test_id, self.zap_sample1_filename, close_old_findings=False, dry_run=True, expected_http_status_code=201
+        )
+
+        changes_close_false = dry_run_close_false["changes_preview"]
+
+        # With close_old_findings=True, should predict more closures
+        self.assertGreaterEqual(
+            changes_close_true["would_close"],
+            changes_close_false["would_close"],
+            "close_old_findings=True should predict more closures",
+        )
+
+        # Verify no actual changes in either case
+        final_findings = self.get_test_findings_api(test_id)
+        active_findings = [f for f in final_findings["results"] if f["active"]]
+        self.assertEqual(len(active_findings), 4, "All original findings should remain active after dry runs")
+
+    def test_dry_run_identical_scan_no_changes(self):
+        """Test dry_run with identical scan predicts no changes"""
+        logger.debug("Testing dry_run with identical scan")
+
+        # Import initial scan
+        with assertTestImportModelsCreated(self, imports=1, affected_findings=4, created=4):
+            import0 = self.import_scan_with_params(self.zap_sample0_filename)
+
+        test_id = import0["test"]
+
+        # Dry run reimport with identical scan
+        dry_run_result = self.reimport_scan_with_params(
+            test_id, self.zap_sample0_filename, dry_run=True, expected_http_status_code=201
+        )
+
+        changes = dry_run_result["changes_preview"]
+
+        # Should predict no changes for identical scan
+        self.assertEqual(changes["would_create"], 0, "Identical scan should create no new findings")
+        self.assertEqual(changes["would_close"], 0, "Identical scan should close no findings")
+        self.assertEqual(changes["would_reactivate"], 0, "Identical scan should reactivate no findings")
+        self.assertEqual(changes["would_leave_untouched"], 4, "All findings should be untouched")
+        self.assertEqual(changes["total_changes"], 0, "Total changes should be zero")
+
+    def test_dry_run_prediction_accuracy(self):
+        """Test that dry_run predictions match actual reimport results"""
+        logger.debug("Testing dry_run prediction accuracy")
+
+        # Import initial scan
+        with assertTestImportModelsCreated(self, imports=1, affected_findings=4, created=4):
+            import0 = self.import_scan_with_params(self.zap_sample0_filename)
+
+        test_id = import0["test"]
+
+        # Perform dry run first
+        dry_run_result = self.reimport_scan_with_params(
+            test_id, self.zap_sample1_filename, close_old_findings=True, dry_run=True, expected_http_status_code=201
+        )
+
+        predicted_changes = dry_run_result["changes_preview"]
+
+        # Now perform actual reimport with same parameters
+        with assertTestImportModelsCreated(self, reimports=1, affected_findings=4, created=1, closed=3, untouched=1):
+            actual_result = self.reimport_scan_with_params(test_id, self.zap_sample1_filename, close_old_findings=True)
+
+        # Verify actual result is not a dry run
+        self.assertFalse(actual_result.get("dry_run", False), "Actual reimport should not be dry run")
+
+        # Get final findings state
+        final_findings = self.get_test_findings_api(test_id)
+        active_findings = [f for f in final_findings["results"] if f["active"]]
+        mitigated_findings = [f for f in final_findings["results"] if f["mitigated"]]
+
+        # Verify predictions were accurate
+        # Note: The exact counts depend on the specific scan files, but the structure should match
+        expected_active = predicted_changes["would_leave_untouched"] + predicted_changes["would_create"]
+        expected_mitigated = predicted_changes["would_close"]
+
+        self.assertEqual(len(active_findings), expected_active, "Active findings count should match dry run prediction")
+        self.assertEqual(
+            len(mitigated_findings), expected_mitigated, "Mitigated findings count should match dry run prediction"
+        )
+
 
 class ImportReimportTestAPI(DojoAPITestCase, ImportReimportMixin):
     fixtures = ["dojo_testdata.json"]
@@ -1760,183 +2090,1194 @@ def setUp(self):
     # - total  findings count should be 5
     # - zap1 active, zap4 inactive
     def test_import_0_reimport_1_active_verified_reimport_0_active_verified_statistics(self):
-        logger.debug("reimporting updated zap xml report, 1 new finding and 1 no longer present, verified=True and then 0 again")
+        logger.debug(
+            "reimporting updated zap xml report, 1 new finding and 1 no longer present, verified=True and then 0 again"
+        )
 
         import0 = self.import_scan_with_params(self.zap_sample0_filename)
 
-        self.assertEqual(import0["statistics"], {
-            "after": {
-                "info": {"active": 0, "verified": 0, "duplicate": 0, "false_p": 0, "out_of_scope": 0, "is_mitigated": 0, "risk_accepted": 0, "total": 0},
-                "low": {"active": 3, "verified": 0, "duplicate": 0, "false_p": 0, "out_of_scope": 0, "is_mitigated": 0, "risk_accepted": 0, "total": 3},
-                "medium": {"active": 1, "verified": 0, "duplicate": 0, "false_p": 0, "out_of_scope": 0, "is_mitigated": 0, "risk_accepted": 0, "total": 1},
-                "high": {"active": 0, "verified": 0, "duplicate": 0, "false_p": 0, "out_of_scope": 0, "is_mitigated": 0, "risk_accepted": 0, "total": 0},
-                "critical": {"active": 0, "verified": 0, "duplicate": 0, "false_p": 0, "out_of_scope": 0, "is_mitigated": 0, "risk_accepted": 0, "total": 0},
-                "total": {"active": 4, "verified": 0, "duplicate": 0, "false_p": 0, "out_of_scope": 0, "is_mitigated": 0, "risk_accepted": 0, "total": 4},
+        self.assertEqual(
+            import0["statistics"],
+            {
+                "after": {
+                    "info": {
+                        "active": 0,
+                        "verified": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "out_of_scope": 0,
+                        "is_mitigated": 0,
+                        "risk_accepted": 0,
+                        "total": 0,
+                    },
+                    "low": {
+                        "active": 3,
+                        "verified": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "out_of_scope": 0,
+                        "is_mitigated": 0,
+                        "risk_accepted": 0,
+                        "total": 3,
+                    },
+                    "medium": {
+                        "active": 1,
+                        "verified": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "out_of_scope": 0,
+                        "is_mitigated": 0,
+                        "risk_accepted": 0,
+                        "total": 1,
+                    },
+                    "high": {
+                        "active": 0,
+                        "verified": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "out_of_scope": 0,
+                        "is_mitigated": 0,
+                        "risk_accepted": 0,
+                        "total": 0,
+                    },
+                    "critical": {
+                        "active": 0,
+                        "verified": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "out_of_scope": 0,
+                        "is_mitigated": 0,
+                        "risk_accepted": 0,
+                        "total": 0,
+                    },
+                    "total": {
+                        "active": 4,
+                        "verified": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "out_of_scope": 0,
+                        "is_mitigated": 0,
+                        "risk_accepted": 0,
+                        "total": 4,
+                    },
+                },
             },
-        })
+        )
 
         test_id = import0["test"]
         reimport1 = self.reimport_scan_with_params(test_id, self.zap_sample1_filename)
 
-        self.assertEqual(reimport1["statistics"], {
-            "after": {
-                "critical": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0},
-                "high": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0},
-                "info": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0},
-                "low": {"active": 3, "duplicate": 0, "false_p": 0, "is_mitigated": 1, "out_of_scope": 0, "risk_accepted": 0, "total": 4, "verified": 0},
-                "medium": {"active": 1, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 1, "verified": 0},
-                "total": {"active": 4, "duplicate": 0, "false_p": 0, "is_mitigated": 1, "out_of_scope": 0, "risk_accepted": 0, "total": 5, "verified": 0}},
-            "before": {
-                "critical": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0},
-                "high": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0},
-                "info": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0},
-                "low": {"active": 3, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 3, "verified": 0},
-                "medium": {"active": 1, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 1, "verified": 0},
-                "total": {"active": 4, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 4, "verified": 0}},
-            "delta": {
-                "closed": {
-                    "critical": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0},
-                    "high": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0},
-                    "info": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0},
-                    "low": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 1, "out_of_scope": 0, "risk_accepted": 0, "total": 1, "verified": 0},
-                    "medium": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0},
-                    "total": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 1, "out_of_scope": 0, "risk_accepted": 0, "total": 1, "verified": 0}},
-                "created": {
-                    "critical": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0},
-                    "high": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0},
-                    "info": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0},
-                    "low": {"active": 1, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 1, "verified": 0},
-                    "medium": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0},
-                    "total": {"active": 1, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 1, "verified": 0}},
-                "untouched": {
-                    "critical": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0},
-                    "high": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0},
-                    "info": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0},
-                    "low": {"active": 2, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 2, "verified": 0},
-                    "medium": {"active": 1, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 1, "verified": 0},
-                    "total": {"active": 3, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 3, "verified": 0}},
-                "reactivated": {
-                    "critical": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0},
-                    "high": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0},
-                    "info": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0},
-                    "low": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0},
-                    "medium": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0},
-                    "total": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0}},
+        self.assertEqual(
+            reimport1["statistics"],
+            {
+                "after": {
+                    "critical": {
+                        "active": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "is_mitigated": 0,
+                        "out_of_scope": 0,
+                        "risk_accepted": 0,
+                        "total": 0,
+                        "verified": 0,
+                    },
+                    "high": {
+                        "active": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "is_mitigated": 0,
+                        "out_of_scope": 0,
+                        "risk_accepted": 0,
+                        "total": 0,
+                        "verified": 0,
+                    },
+                    "info": {
+                        "active": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "is_mitigated": 0,
+                        "out_of_scope": 0,
+                        "risk_accepted": 0,
+                        "total": 0,
+                        "verified": 0,
+                    },
+                    "low": {
+                        "active": 3,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "is_mitigated": 1,
+                        "out_of_scope": 0,
+                        "risk_accepted": 0,
+                        "total": 4,
+                        "verified": 0,
+                    },
+                    "medium": {
+                        "active": 1,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "is_mitigated": 0,
+                        "out_of_scope": 0,
+                        "risk_accepted": 0,
+                        "total": 1,
+                        "verified": 0,
+                    },
+                    "total": {
+                        "active": 4,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "is_mitigated": 1,
+                        "out_of_scope": 0,
+                        "risk_accepted": 0,
+                        "total": 5,
+                        "verified": 0,
+                    },
+                },
+                "before": {
+                    "critical": {
+                        "active": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "is_mitigated": 0,
+                        "out_of_scope": 0,
+                        "risk_accepted": 0,
+                        "total": 0,
+                        "verified": 0,
+                    },
+                    "high": {
+                        "active": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "is_mitigated": 0,
+                        "out_of_scope": 0,
+                        "risk_accepted": 0,
+                        "total": 0,
+                        "verified": 0,
+                    },
+                    "info": {
+                        "active": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "is_mitigated": 0,
+                        "out_of_scope": 0,
+                        "risk_accepted": 0,
+                        "total": 0,
+                        "verified": 0,
+                    },
+                    "low": {
+                        "active": 3,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "is_mitigated": 0,
+                        "out_of_scope": 0,
+                        "risk_accepted": 0,
+                        "total": 3,
+                        "verified": 0,
+                    },
+                    "medium": {
+                        "active": 1,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "is_mitigated": 0,
+                        "out_of_scope": 0,
+                        "risk_accepted": 0,
+                        "total": 1,
+                        "verified": 0,
+                    },
+                    "total": {
+                        "active": 4,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "is_mitigated": 0,
+                        "out_of_scope": 0,
+                        "risk_accepted": 0,
+                        "total": 4,
+                        "verified": 0,
+                    },
+                },
+                "delta": {
+                    "closed": {
+                        "critical": {
+                            "active": 0,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 0,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 0,
+                            "verified": 0,
+                        },
+                        "high": {
+                            "active": 0,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 0,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 0,
+                            "verified": 0,
+                        },
+                        "info": {
+                            "active": 0,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 0,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 0,
+                            "verified": 0,
+                        },
+                        "low": {
+                            "active": 0,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 1,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 1,
+                            "verified": 0,
+                        },
+                        "medium": {
+                            "active": 0,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 0,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 0,
+                            "verified": 0,
+                        },
+                        "total": {
+                            "active": 0,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 1,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 1,
+                            "verified": 0,
+                        },
+                    },
+                    "created": {
+                        "critical": {
+                            "active": 0,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 0,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 0,
+                            "verified": 0,
+                        },
+                        "high": {
+                            "active": 0,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 0,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 0,
+                            "verified": 0,
+                        },
+                        "info": {
+                            "active": 0,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 0,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 0,
+                            "verified": 0,
+                        },
+                        "low": {
+                            "active": 1,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 0,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 1,
+                            "verified": 0,
+                        },
+                        "medium": {
+                            "active": 0,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 0,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 0,
+                            "verified": 0,
+                        },
+                        "total": {
+                            "active": 1,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 0,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 1,
+                            "verified": 0,
+                        },
+                    },
+                    "untouched": {
+                        "critical": {
+                            "active": 0,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 0,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 0,
+                            "verified": 0,
+                        },
+                        "high": {
+                            "active": 0,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 0,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 0,
+                            "verified": 0,
+                        },
+                        "info": {
+                            "active": 0,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 0,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 0,
+                            "verified": 0,
+                        },
+                        "low": {
+                            "active": 2,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 0,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 2,
+                            "verified": 0,
+                        },
+                        "medium": {
+                            "active": 1,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 0,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 1,
+                            "verified": 0,
+                        },
+                        "total": {
+                            "active": 3,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 0,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 3,
+                            "verified": 0,
+                        },
+                    },
+                    "reactivated": {
+                        "critical": {
+                            "active": 0,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 0,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 0,
+                            "verified": 0,
+                        },
+                        "high": {
+                            "active": 0,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 0,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 0,
+                            "verified": 0,
+                        },
+                        "info": {
+                            "active": 0,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 0,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 0,
+                            "verified": 0,
+                        },
+                        "low": {
+                            "active": 0,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 0,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 0,
+                            "verified": 0,
+                        },
+                        "medium": {
+                            "active": 0,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 0,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 0,
+                            "verified": 0,
+                        },
+                        "total": {
+                            "active": 0,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 0,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 0,
+                            "verified": 0,
+                        },
+                    },
+                },
             },
-        })
+        )
 
-        with assertTestImportModelsCreated(self, reimports=1, affected_findings=2, closed=1, reactivated=1, untouched=3):
+        with assertTestImportModelsCreated(
+            self, reimports=1, affected_findings=2, closed=1, reactivated=1, untouched=3
+        ):
             reimport0 = self.reimport_scan_with_params(test_id, self.zap_sample0_filename)
 
-        self.assertEqual(reimport0["statistics"], {
-            "after": {
-                "critical": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0},
-                "high": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0},
-                "info": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0},
-                "low": {"active": 3, "duplicate": 0, "false_p": 0, "is_mitigated": 1, "out_of_scope": 0, "risk_accepted": 0, "total": 4, "verified": 0},
-                "medium": {"active": 1, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 1, "verified": 0},
-                "total": {"active": 4, "duplicate": 0, "false_p": 0, "is_mitigated": 1, "out_of_scope": 0, "risk_accepted": 0, "total": 5, "verified": 0}},
-            "before": {
-                "critical": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0},
-                "high": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0},
-                "info": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0},
-                "low": {"active": 3, "duplicate": 0, "false_p": 0, "is_mitigated": 1, "out_of_scope": 0, "risk_accepted": 0, "total": 4, "verified": 0},
-                "medium": {"active": 1, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 1, "verified": 0},
-                "total": {"active": 4, "duplicate": 0, "false_p": 0, "is_mitigated": 1, "out_of_scope": 0, "risk_accepted": 0, "total": 5, "verified": 0}},
-            "delta": {
-                "closed": {
-                    "critical": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0},
-                    "high": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0},
-                    "info": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0},
-                    "low": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 1, "out_of_scope": 0, "risk_accepted": 0, "total": 1, "verified": 0},
-                    "medium": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0},
-                    "total": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 1, "out_of_scope": 0, "risk_accepted": 0, "total": 1, "verified": 0}},
-                "created": {
-                    "critical": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0},
-                    "high": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0},
-                    "info": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0},
-                    "low": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0},
-                    "medium": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0},
-                    "total": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0}},
-                "untouched": {
-                    "critical": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0},
-                    "high": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0},
-                    "info": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0},
-                    "low": {"active": 2, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 2, "verified": 0},
-                    "medium": {"active": 1, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 1, "verified": 0},
-                    "total": {"active": 3, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 3, "verified": 0}},
-                "reactivated": {
-                    "critical": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0},
-                    "high": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0},
-                    "info": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0},
-                    "low": {"active": 1, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 1, "verified": 0},
-                    "medium": {"active": 0, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 0, "verified": 0},
-                    "total": {"active": 1, "duplicate": 0, "false_p": 0, "is_mitigated": 0, "out_of_scope": 0, "risk_accepted": 0, "total": 1, "verified": 0}},
+        self.assertEqual(
+            reimport0["statistics"],
+            {
+                "after": {
+                    "critical": {
+                        "active": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "is_mitigated": 0,
+                        "out_of_scope": 0,
+                        "risk_accepted": 0,
+                        "total": 0,
+                        "verified": 0,
+                    },
+                    "high": {
+                        "active": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "is_mitigated": 0,
+                        "out_of_scope": 0,
+                        "risk_accepted": 0,
+                        "total": 0,
+                        "verified": 0,
+                    },
+                    "info": {
+                        "active": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "is_mitigated": 0,
+                        "out_of_scope": 0,
+                        "risk_accepted": 0,
+                        "total": 0,
+                        "verified": 0,
+                    },
+                    "low": {
+                        "active": 3,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "is_mitigated": 1,
+                        "out_of_scope": 0,
+                        "risk_accepted": 0,
+                        "total": 4,
+                        "verified": 0,
+                    },
+                    "medium": {
+                        "active": 1,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "is_mitigated": 0,
+                        "out_of_scope": 0,
+                        "risk_accepted": 0,
+                        "total": 1,
+                        "verified": 0,
+                    },
+                    "total": {
+                        "active": 4,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "is_mitigated": 1,
+                        "out_of_scope": 0,
+                        "risk_accepted": 0,
+                        "total": 5,
+                        "verified": 0,
+                    },
+                },
+                "before": {
+                    "critical": {
+                        "active": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "is_mitigated": 0,
+                        "out_of_scope": 0,
+                        "risk_accepted": 0,
+                        "total": 0,
+                        "verified": 0,
+                    },
+                    "high": {
+                        "active": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "is_mitigated": 0,
+                        "out_of_scope": 0,
+                        "risk_accepted": 0,
+                        "total": 0,
+                        "verified": 0,
+                    },
+                    "info": {
+                        "active": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "is_mitigated": 0,
+                        "out_of_scope": 0,
+                        "risk_accepted": 0,
+                        "total": 0,
+                        "verified": 0,
+                    },
+                    "low": {
+                        "active": 3,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "is_mitigated": 1,
+                        "out_of_scope": 0,
+                        "risk_accepted": 0,
+                        "total": 4,
+                        "verified": 0,
+                    },
+                    "medium": {
+                        "active": 1,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "is_mitigated": 0,
+                        "out_of_scope": 0,
+                        "risk_accepted": 0,
+                        "total": 1,
+                        "verified": 0,
+                    },
+                    "total": {
+                        "active": 4,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "is_mitigated": 1,
+                        "out_of_scope": 0,
+                        "risk_accepted": 0,
+                        "total": 5,
+                        "verified": 0,
+                    },
+                },
+                "delta": {
+                    "closed": {
+                        "critical": {
+                            "active": 0,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 0,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 0,
+                            "verified": 0,
+                        },
+                        "high": {
+                            "active": 0,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 0,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 0,
+                            "verified": 0,
+                        },
+                        "info": {
+                            "active": 0,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 0,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 0,
+                            "verified": 0,
+                        },
+                        "low": {
+                            "active": 0,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 1,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 1,
+                            "verified": 0,
+                        },
+                        "medium": {
+                            "active": 0,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 0,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 0,
+                            "verified": 0,
+                        },
+                        "total": {
+                            "active": 0,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 1,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 1,
+                            "verified": 0,
+                        },
+                    },
+                    "created": {
+                        "critical": {
+                            "active": 0,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 0,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 0,
+                            "verified": 0,
+                        },
+                        "high": {
+                            "active": 0,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 0,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 0,
+                            "verified": 0,
+                        },
+                        "info": {
+                            "active": 0,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 0,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 0,
+                            "verified": 0,
+                        },
+                        "low": {
+                            "active": 0,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 0,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 0,
+                            "verified": 0,
+                        },
+                        "medium": {
+                            "active": 0,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 0,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 0,
+                            "verified": 0,
+                        },
+                        "total": {
+                            "active": 0,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 0,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 0,
+                            "verified": 0,
+                        },
+                    },
+                    "untouched": {
+                        "critical": {
+                            "active": 0,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 0,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 0,
+                            "verified": 0,
+                        },
+                        "high": {
+                            "active": 0,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 0,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 0,
+                            "verified": 0,
+                        },
+                        "info": {
+                            "active": 0,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 0,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 0,
+                            "verified": 0,
+                        },
+                        "low": {
+                            "active": 2,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 0,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 2,
+                            "verified": 0,
+                        },
+                        "medium": {
+                            "active": 1,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 0,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 1,
+                            "verified": 0,
+                        },
+                        "total": {
+                            "active": 3,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 0,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 3,
+                            "verified": 0,
+                        },
+                    },
+                    "reactivated": {
+                        "critical": {
+                            "active": 0,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 0,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 0,
+                            "verified": 0,
+                        },
+                        "high": {
+                            "active": 0,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 0,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 0,
+                            "verified": 0,
+                        },
+                        "info": {
+                            "active": 0,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 0,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 0,
+                            "verified": 0,
+                        },
+                        "low": {
+                            "active": 1,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 0,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 1,
+                            "verified": 0,
+                        },
+                        "medium": {
+                            "active": 0,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 0,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 0,
+                            "verified": 0,
+                        },
+                        "total": {
+                            "active": 1,
+                            "duplicate": 0,
+                            "false_p": 0,
+                            "is_mitigated": 0,
+                            "out_of_scope": 0,
+                            "risk_accepted": 0,
+                            "total": 1,
+                            "verified": 0,
+                        },
+                    },
+                },
             },
-        })
+        )
 
     # without import history, there are no delta statistics
     @override_settings(TRACK_IMPORT_HISTORY=False)
     def test_import_0_reimport_1_active_verified_reimport_0_active_verified_statistics_no_history(self):
-        logger.debug("reimporting updated zap xml report, 1 new finding and 1 no longer present, verified=True and then 0 again")
+        logger.debug(
+            "reimporting updated zap xml report, 1 new finding and 1 no longer present, verified=True and then 0 again"
+        )
 
         import0 = self.import_scan_with_params(self.zap_sample0_filename)
 
-        self.assertEqual(import0["statistics"], {
-            "after": {
-                "info": {"active": 0, "verified": 0, "duplicate": 0, "false_p": 0, "out_of_scope": 0, "is_mitigated": 0, "risk_accepted": 0, "total": 0},
-                "low": {"active": 3, "verified": 0, "duplicate": 0, "false_p": 0, "out_of_scope": 0, "is_mitigated": 0, "risk_accepted": 0, "total": 3},
-                "medium": {"active": 1, "verified": 0, "duplicate": 0, "false_p": 0, "out_of_scope": 0, "is_mitigated": 0, "risk_accepted": 0, "total": 1},
-                "high": {"active": 0, "verified": 0, "duplicate": 0, "false_p": 0, "out_of_scope": 0, "is_mitigated": 0, "risk_accepted": 0, "total": 0},
-                "critical": {"active": 0, "verified": 0, "duplicate": 0, "false_p": 0, "out_of_scope": 0, "is_mitigated": 0, "risk_accepted": 0, "total": 0},
-                "total": {"active": 4, "verified": 0, "duplicate": 0, "false_p": 0, "out_of_scope": 0, "is_mitigated": 0, "risk_accepted": 0, "total": 4},
+        self.assertEqual(
+            import0["statistics"],
+            {
+                "after": {
+                    "info": {
+                        "active": 0,
+                        "verified": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "out_of_scope": 0,
+                        "is_mitigated": 0,
+                        "risk_accepted": 0,
+                        "total": 0,
+                    },
+                    "low": {
+                        "active": 3,
+                        "verified": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "out_of_scope": 0,
+                        "is_mitigated": 0,
+                        "risk_accepted": 0,
+                        "total": 3,
+                    },
+                    "medium": {
+                        "active": 1,
+                        "verified": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "out_of_scope": 0,
+                        "is_mitigated": 0,
+                        "risk_accepted": 0,
+                        "total": 1,
+                    },
+                    "high": {
+                        "active": 0,
+                        "verified": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "out_of_scope": 0,
+                        "is_mitigated": 0,
+                        "risk_accepted": 0,
+                        "total": 0,
+                    },
+                    "critical": {
+                        "active": 0,
+                        "verified": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "out_of_scope": 0,
+                        "is_mitigated": 0,
+                        "risk_accepted": 0,
+                        "total": 0,
+                    },
+                    "total": {
+                        "active": 4,
+                        "verified": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "out_of_scope": 0,
+                        "is_mitigated": 0,
+                        "risk_accepted": 0,
+                        "total": 4,
+                    },
+                },
             },
-        })
+        )
 
         test_id = import0["test"]
 
         reimport1 = self.reimport_scan_with_params(test_id, self.zap_sample1_filename)
 
-        self.assertEqual(reimport1["statistics"], {
-            "before": {
-                "info": {"active": 0, "verified": 0, "duplicate": 0, "false_p": 0, "out_of_scope": 0, "is_mitigated": 0, "risk_accepted": 0, "total": 0},
-                "low": {"active": 3, "verified": 0, "duplicate": 0, "false_p": 0, "out_of_scope": 0, "is_mitigated": 0, "risk_accepted": 0, "total": 3},
-                "medium": {"active": 1, "verified": 0, "duplicate": 0, "false_p": 0, "out_of_scope": 0, "is_mitigated": 0, "risk_accepted": 0, "total": 1},
-                "high": {"active": 0, "verified": 0, "duplicate": 0, "false_p": 0, "out_of_scope": 0, "is_mitigated": 0, "risk_accepted": 0, "total": 0},
-                "critical": {"active": 0, "verified": 0, "duplicate": 0, "false_p": 0, "out_of_scope": 0, "is_mitigated": 0, "risk_accepted": 0, "total": 0},
-                "total": {"active": 4, "verified": 0, "duplicate": 0, "false_p": 0, "out_of_scope": 0, "is_mitigated": 0, "risk_accepted": 0, "total": 4},
+        self.assertEqual(
+            reimport1["statistics"],
+            {
+                "before": {
+                    "info": {
+                        "active": 0,
+                        "verified": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "out_of_scope": 0,
+                        "is_mitigated": 0,
+                        "risk_accepted": 0,
+                        "total": 0,
+                    },
+                    "low": {
+                        "active": 3,
+                        "verified": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "out_of_scope": 0,
+                        "is_mitigated": 0,
+                        "risk_accepted": 0,
+                        "total": 3,
+                    },
+                    "medium": {
+                        "active": 1,
+                        "verified": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "out_of_scope": 0,
+                        "is_mitigated": 0,
+                        "risk_accepted": 0,
+                        "total": 1,
+                    },
+                    "high": {
+                        "active": 0,
+                        "verified": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "out_of_scope": 0,
+                        "is_mitigated": 0,
+                        "risk_accepted": 0,
+                        "total": 0,
+                    },
+                    "critical": {
+                        "active": 0,
+                        "verified": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "out_of_scope": 0,
+                        "is_mitigated": 0,
+                        "risk_accepted": 0,
+                        "total": 0,
+                    },
+                    "total": {
+                        "active": 4,
+                        "verified": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "out_of_scope": 0,
+                        "is_mitigated": 0,
+                        "risk_accepted": 0,
+                        "total": 4,
+                    },
+                },
+                "after": {
+                    "info": {
+                        "active": 0,
+                        "verified": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "out_of_scope": 0,
+                        "is_mitigated": 0,
+                        "risk_accepted": 0,
+                        "total": 0,
+                    },
+                    "low": {
+                        "active": 3,
+                        "verified": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "out_of_scope": 0,
+                        "is_mitigated": 1,
+                        "risk_accepted": 0,
+                        "total": 4,
+                    },
+                    "medium": {
+                        "active": 1,
+                        "verified": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "out_of_scope": 0,
+                        "is_mitigated": 0,
+                        "risk_accepted": 0,
+                        "total": 1,
+                    },
+                    "high": {
+                        "active": 0,
+                        "verified": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "out_of_scope": 0,
+                        "is_mitigated": 0,
+                        "risk_accepted": 0,
+                        "total": 0,
+                    },
+                    "critical": {
+                        "active": 0,
+                        "verified": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "out_of_scope": 0,
+                        "is_mitigated": 0,
+                        "risk_accepted": 0,
+                        "total": 0,
+                    },
+                    "total": {
+                        "active": 4,
+                        "verified": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "out_of_scope": 0,
+                        "is_mitigated": 1,
+                        "risk_accepted": 0,
+                        "total": 5,
+                    },
+                },
             },
-            "after": {
-                "info": {"active": 0, "verified": 0, "duplicate": 0, "false_p": 0, "out_of_scope": 0, "is_mitigated": 0, "risk_accepted": 0, "total": 0},
-                "low": {"active": 3, "verified": 0, "duplicate": 0, "false_p": 0, "out_of_scope": 0, "is_mitigated": 1, "risk_accepted": 0, "total": 4},
-                "medium": {"active": 1, "verified": 0, "duplicate": 0, "false_p": 0, "out_of_scope": 0, "is_mitigated": 0, "risk_accepted": 0, "total": 1},
-                "high": {"active": 0, "verified": 0, "duplicate": 0, "false_p": 0, "out_of_scope": 0, "is_mitigated": 0, "risk_accepted": 0, "total": 0},
-                "critical": {"active": 0, "verified": 0, "duplicate": 0, "false_p": 0, "out_of_scope": 0, "is_mitigated": 0, "risk_accepted": 0, "total": 0},
-                "total": {"active": 4, "verified": 0, "duplicate": 0, "false_p": 0, "out_of_scope": 0, "is_mitigated": 1, "risk_accepted": 0, "total": 5},
-            },
-        })
+        )
 
-        with assertTestImportModelsCreated(self, reimports=0, affected_findings=0, closed=0, reactivated=0, untouched=0):
+        with assertTestImportModelsCreated(
+            self, reimports=0, affected_findings=0, closed=0, reactivated=0, untouched=0
+        ):
             reimport0 = self.reimport_scan_with_params(test_id, self.zap_sample0_filename)
 
-        self.assertEqual(reimport0["statistics"], {
-            "before": {
-                "info": {"active": 0, "verified": 0, "duplicate": 0, "false_p": 0, "out_of_scope": 0, "is_mitigated": 0, "risk_accepted": 0, "total": 0},
-                "low": {"active": 3, "verified": 0, "duplicate": 0, "false_p": 0, "out_of_scope": 0, "is_mitigated": 1, "risk_accepted": 0, "total": 4},
-                "medium": {"active": 1, "verified": 0, "duplicate": 0, "false_p": 0, "out_of_scope": 0, "is_mitigated": 0, "risk_accepted": 0, "total": 1},
-                "high": {"active": 0, "verified": 0, "duplicate": 0, "false_p": 0, "out_of_scope": 0, "is_mitigated": 0, "risk_accepted": 0, "total": 0},
-                "critical": {"active": 0, "verified": 0, "duplicate": 0, "false_p": 0, "out_of_scope": 0, "is_mitigated": 0, "risk_accepted": 0, "total": 0},
-                "total": {"active": 4, "verified": 0, "duplicate": 0, "false_p": 0, "out_of_scope": 0, "is_mitigated": 1, "risk_accepted": 0, "total": 5},
+        self.assertEqual(
+            reimport0["statistics"],
+            {
+                "before": {
+                    "info": {
+                        "active": 0,
+                        "verified": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "out_of_scope": 0,
+                        "is_mitigated": 0,
+                        "risk_accepted": 0,
+                        "total": 0,
+                    },
+                    "low": {
+                        "active": 3,
+                        "verified": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "out_of_scope": 0,
+                        "is_mitigated": 1,
+                        "risk_accepted": 0,
+                        "total": 4,
+                    },
+                    "medium": {
+                        "active": 1,
+                        "verified": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "out_of_scope": 0,
+                        "is_mitigated": 0,
+                        "risk_accepted": 0,
+                        "total": 1,
+                    },
+                    "high": {
+                        "active": 0,
+                        "verified": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "out_of_scope": 0,
+                        "is_mitigated": 0,
+                        "risk_accepted": 0,
+                        "total": 0,
+                    },
+                    "critical": {
+                        "active": 0,
+                        "verified": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "out_of_scope": 0,
+                        "is_mitigated": 0,
+                        "risk_accepted": 0,
+                        "total": 0,
+                    },
+                    "total": {
+                        "active": 4,
+                        "verified": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "out_of_scope": 0,
+                        "is_mitigated": 1,
+                        "risk_accepted": 0,
+                        "total": 5,
+                    },
+                },
+                "after": {
+                    "info": {
+                        "active": 0,
+                        "verified": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "out_of_scope": 0,
+                        "is_mitigated": 0,
+                        "risk_accepted": 0,
+                        "total": 0,
+                    },
+                    "low": {
+                        "active": 3,
+                        "verified": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "out_of_scope": 0,
+                        "is_mitigated": 1,
+                        "risk_accepted": 0,
+                        "total": 4,
+                    },
+                    "medium": {
+                        "active": 1,
+                        "verified": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "out_of_scope": 0,
+                        "is_mitigated": 0,
+                        "risk_accepted": 0,
+                        "total": 1,
+                    },
+                    "high": {
+                        "active": 0,
+                        "verified": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "out_of_scope": 0,
+                        "is_mitigated": 0,
+                        "risk_accepted": 0,
+                        "total": 0,
+                    },
+                    "critical": {
+                        "active": 0,
+                        "verified": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "out_of_scope": 0,
+                        "is_mitigated": 0,
+                        "risk_accepted": 0,
+                        "total": 0,
+                    },
+                    "total": {
+                        "active": 4,
+                        "verified": 0,
+                        "duplicate": 0,
+                        "false_p": 0,
+                        "out_of_scope": 0,
+                        "is_mitigated": 1,
+                        "risk_accepted": 0,
+                        "total": 5,
+                    },
+                },
             },
-            "after": {
-                "info": {"active": 0, "verified": 0, "duplicate": 0, "false_p": 0, "out_of_scope": 0, "is_mitigated": 0, "risk_accepted": 0, "total": 0},
-                "low": {"active": 3, "verified": 0, "duplicate": 0, "false_p": 0, "out_of_scope": 0, "is_mitigated": 1, "risk_accepted": 0, "total": 4},
-                "medium": {"active": 1, "verified": 0, "duplicate": 0, "false_p": 0, "out_of_scope": 0, "is_mitigated": 0, "risk_accepted": 0, "total": 1},
-                "high": {"active": 0, "verified": 0, "duplicate": 0, "false_p": 0, "out_of_scope": 0, "is_mitigated": 0, "risk_accepted": 0, "total": 0},
-                "critical": {"active": 0, "verified": 0, "duplicate": 0, "false_p": 0, "out_of_scope": 0, "is_mitigated": 0, "risk_accepted": 0, "total": 0},
-                "total": {"active": 4, "verified": 0, "duplicate": 0, "false_p": 0, "out_of_scope": 0, "is_mitigated": 1, "risk_accepted": 0, "total": 5},
-            },
-        })
+        )
+
     # Reimport tests to test Scan_Date logic (usecase not supported on UI)
 
     # reimport zap scan without dates (non existing test, so import is called inside DD)
@@ -1945,8 +3286,17 @@ def test_import_0_reimport_1_active_verified_reimport_0_active_verified_statisti
     def test_reimport_default_scan_date_parser_not_sets_date(self):
         logger.debug("importing zap xml report with date set by parser")
         with assertTestImportModelsCreated(self, imports=1, affected_findings=4, created=4):
-            import0 = self.reimport_scan_with_params(None, self.zap_sample0_filename, active=False, verified=False,
-                product_name=PRODUCT_NAME_DEFAULT, engagement=None, engagement_name=ENGAGEMENT_NAME_DEFAULT, product_type_name=PRODUCT_TYPE_NAME_DEFAULT, auto_create_context=True)
+            import0 = self.reimport_scan_with_params(
+                None,
+                self.zap_sample0_filename,
+                active=False,
+                verified=False,
+                product_name=PRODUCT_NAME_DEFAULT,
+                engagement=None,
+                engagement_name=ENGAGEMENT_NAME_DEFAULT,
+                product_type_name=PRODUCT_TYPE_NAME_DEFAULT,
+                auto_create_context=True,
+            )
 
         test_id = import0["test"]
         findings = self.get_test_findings_api(test_id, active=False, verified=False)
@@ -1962,8 +3312,18 @@ def test_reimport_default_scan_date_parser_not_sets_date(self):
     def test_reimport_default_scan_date_parser_sets_date(self):
         logger.debug("importing original acunetix xml report")
         with assertTestImportModelsCreated(self, imports=1, affected_findings=1, created=1):
-            import0 = self.reimport_scan_with_params(None, self.acunetix_file_name, scan_type=self.scan_type_acunetix, active=False, verified=False,
-                product_name=PRODUCT_NAME_DEFAULT, engagement=None, engagement_name=ENGAGEMENT_NAME_DEFAULT, product_type_name=PRODUCT_TYPE_NAME_DEFAULT, auto_create_context=True)
+            import0 = self.reimport_scan_with_params(
+                None,
+                self.acunetix_file_name,
+                scan_type=self.scan_type_acunetix,
+                active=False,
+                verified=False,
+                product_name=PRODUCT_NAME_DEFAULT,
+                engagement=None,
+                engagement_name=ENGAGEMENT_NAME_DEFAULT,
+                product_type_name=PRODUCT_TYPE_NAME_DEFAULT,
+                auto_create_context=True,
+            )
 
         test_id = import0["test"]
         findings = self.get_test_findings_api(test_id, active=False, verified=False)
@@ -1979,8 +3339,18 @@ def test_reimport_default_scan_date_parser_sets_date(self):
     def test_reimport_set_scan_date_parser_not_sets_date(self):
         logger.debug("importing original zap xml report")
         with assertTestImportModelsCreated(self, imports=1, affected_findings=4, created=4):
-            import0 = self.reimport_scan_with_params(None, self.zap_sample0_filename, active=False, verified=False, scan_date="2006-12-26",
-                            product_name=PRODUCT_NAME_DEFAULT, engagement=None, engagement_name=ENGAGEMENT_NAME_DEFAULT, product_type_name=PRODUCT_TYPE_NAME_DEFAULT, auto_create_context=True)
+            import0 = self.reimport_scan_with_params(
+                None,
+                self.zap_sample0_filename,
+                active=False,
+                verified=False,
+                scan_date="2006-12-26",
+                product_name=PRODUCT_NAME_DEFAULT,
+                engagement=None,
+                engagement_name=ENGAGEMENT_NAME_DEFAULT,
+                product_type_name=PRODUCT_TYPE_NAME_DEFAULT,
+                auto_create_context=True,
+            )
 
         test_id = import0["test"]
         findings = self.get_test_findings_api(test_id, active=False, verified=False)
@@ -1996,8 +3366,19 @@ def test_reimport_set_scan_date_parser_not_sets_date(self):
     def test_reimport_set_scan_date_parser_sets_date(self):
         logger.debug("importing acunetix xml report with date set by parser")
         with assertTestImportModelsCreated(self, imports=1, affected_findings=1, created=1):
-            import0 = self.reimport_scan_with_params(None, self.acunetix_file_name, scan_type=self.scan_type_acunetix, active=False, verified=False, scan_date="2006-12-26",
-                            product_name=PRODUCT_NAME_DEFAULT, engagement=None, engagement_name=ENGAGEMENT_NAME_DEFAULT, product_type_name=PRODUCT_TYPE_NAME_DEFAULT, auto_create_context=True)
+            import0 = self.reimport_scan_with_params(
+                None,
+                self.acunetix_file_name,
+                scan_type=self.scan_type_acunetix,
+                active=False,
+                verified=False,
+                scan_date="2006-12-26",
+                product_name=PRODUCT_NAME_DEFAULT,
+                engagement=None,
+                engagement_name=ENGAGEMENT_NAME_DEFAULT,
+                product_type_name=PRODUCT_TYPE_NAME_DEFAULT,
+                auto_create_context=True,
+            )
 
         test_id = import0["test"]
         findings = self.get_test_findings_api(test_id, active=False, verified=False)
@@ -2046,7 +3427,7 @@ def reimport_scan_with_params(self, *args, **kwargs):
     def import_scan_ui(self, engagement, payload):
         logger.debug("import_scan payload %s", payload)
         # response = self.client_ui.post(reverse('import_scan_results', args=(engagement, )), urlencode(payload), content_type='application/x-www-form-urlencoded')
-        response = self.client_ui.post(reverse("import_scan_results", args=(engagement, )), payload)
+        response = self.client_ui.post(reverse("import_scan_results", args=(engagement,)), payload)
 
         url_split = response.url.split("/")
         self.assertEqual(url_split[1], "test", response.url)
@@ -2062,7 +3443,7 @@ def import_scan_ui(self, engagement, payload):
         return {"test": test.id}
 
     def reimport_scan_ui(self, test, payload):
-        response = self.client_ui.post(reverse("re_import_scan_results", args=(test, )), payload)
+        response = self.client_ui.post(reverse("re_import_scan_results", args=(test,)), payload)
         self.assertEqual(302, response.status_code, response.content[:1000])
         # If the response URL contains 're_import_scan_results', it means the import failed
         if "re_import_scan_results" in response.url:
@@ -2071,10 +3452,24 @@ def reimport_scan_ui(self, test, payload):
         test = Test.objects.get(id=response.url.split("/")[-1])
         return {"test": test.id}
 
-    def import_scan_with_params_ui(self, filename, scan_type="ZAP Scan", engagement=1, minimum_severity="Low", *, active=True, verified=False,
-                                   push_to_jira=None, endpoint_to_add=None, tags=None, close_old_findings=False, scan_date=None, service=None,
-                                   force_active=False, force_verified=False):
-
+    def import_scan_with_params_ui(
+        self,
+        filename,
+        scan_type="ZAP Scan",
+        engagement=1,
+        minimum_severity="Low",
+        *,
+        active=True,
+        verified=False,
+        push_to_jira=None,
+        endpoint_to_add=None,
+        tags=None,
+        close_old_findings=False,
+        scan_date=None,
+        service=None,
+        force_active=False,
+        force_verified=False,
+    ):
         activePayload = "not_specified"
         if force_active:
             activePayload = "force_to_true"
@@ -2089,14 +3484,14 @@ def import_scan_with_params_ui(self, filename, scan_type="ZAP Scan", engagement=
 
         with Path(filename).open(encoding="utf-8") as testfile:
             payload = {
-                    "minimum_severity": minimum_severity,
-                    "active": activePayload,
-                    "verified": verifiedPayload,
-                    "scan_type": scan_type,
-                    "file": testfile,
-                    "environment": 1,
-                    "version": "1.0.1",
-                    "close_old_findings": close_old_findings,
+                "minimum_severity": minimum_severity,
+                "active": activePayload,
+                "verified": verifiedPayload,
+                "scan_type": scan_type,
+                "file": testfile,
+                "environment": 1,
+                "version": "1.0.1",
+                "close_old_findings": close_old_findings,
             }
 
             if push_to_jira is not None:
@@ -2118,8 +3513,21 @@ def import_scan_with_params_ui(self, filename, scan_type="ZAP Scan", engagement=
 
     # For UI tests we cannot rely on the default for close_old_findings True as when we leave out the field in the request,
     # Django (or rathet HTML FORM spec) will interpret that as False. So we explicitly set it to True here.
-    def reimport_scan_with_params_ui(self, test_id, filename, scan_type="ZAP Scan", minimum_severity="Low", *, active=True, verified=False, push_to_jira=None, tags=None,
-            close_old_findings=True, scan_date=None, service=None):
+    def reimport_scan_with_params_ui(
+        self,
+        test_id,
+        filename,
+        scan_type="ZAP Scan",
+        minimum_severity="Low",
+        *,
+        active=True,
+        verified=False,
+        push_to_jira=None,
+        tags=None,
+        close_old_findings=True,
+        scan_date=None,
+        service=None,
+    ):
         # Mimic old functionality for active/verified to avoid breaking tests
         activePayload = "force_to_true"
         if not active:
@@ -2130,13 +3538,13 @@ def reimport_scan_with_params_ui(self, test_id, filename, scan_type="ZAP Scan",
 
         with Path(filename).open(encoding="utf-8") as testfile:
             payload = {
-                    "minimum_severity": minimum_severity,
-                    "active": activePayload,
-                    "verified": verifiedPayload,
-                    "scan_type": scan_type,
-                    "file": testfile,
-                    "version": "1.0.1",
-                    "close_old_findings": close_old_findings,
+                "minimum_severity": minimum_severity,
+                "active": activePayload,
+                "verified": verifiedPayload,
+                "scan_type": scan_type,
+                "file": testfile,
+                "version": "1.0.1",
+                "close_old_findings": close_old_findings,
             }
 
             if push_to_jira is not None:
@@ -2153,6 +3561,7 @@ def reimport_scan_with_params_ui(self, test_id, filename, scan_type="ZAP Scan",
 
             return self.reimport_scan_ui(test_id, payload)
 
+
 # Observations:
 # - When reopening a mitigated finding, almost no fields are updated such as title, description, severity, impact, references, ....
 # - Basically fields (and req/resp) are only stored on the initial import, reimporting only changes the active/mitigated/verified flags + some dates + notes
diff --git a/unittests/test_import_reimport_dry_run.py b/unittests/test_import_reimport_dry_run.py
new file mode 100644
index 00000000000..80c536c52f7
--- /dev/null
+++ b/unittests/test_import_reimport_dry_run.py
@@ -0,0 +1,368 @@
+import logging
+from pathlib import Path
+
+from .dojo_test_case import DojoAPITestCase, get_unit_tests_scans_path
+from .test_utils import assertTestImportModelsCreated
+
+logger = logging.getLogger(__name__)
+
+
+class ImportReimportDryRunTest(DojoAPITestCase):
+    """
+    Test class for testing the dry_run functionality in reimport scans.
+    Ensures that dry_run mode performs analysis without making database changes.
+    """
+
+    fixtures = ["dojo_testdata.json"]
+
+    def setUp(self):
+        super().setUp()
+        self.login_as_admin()
+        # Test files for dry run testing
+        self.zap_sample0_filename = get_unit_tests_scans_path("zap") / "0_zap_sample.xml"
+        self.zap_sample1_filename = get_unit_tests_scans_path("zap") / "1_zap_sample_0_and_new_absent.xml"
+        self.zap_sample3_filename = get_unit_tests_scans_path("zap") / "3_zap_sampl_0_and_different_severities.xml"
+
+        self.veracode_many_findings = get_unit_tests_scans_path("veracode") / "many_findings.xml"
+        self.veracode_mitigated_findings = get_unit_tests_scans_path("veracode") / "mitigated_finding.xml"
+        self.scan_type_veracode = "Veracode Scan"
+
+    def reimport_scan_with_dry_run(
+        self,
+        test_id,
+        filename,
+        scan_type="ZAP Scan",
+        minimum_severity="Low",
+        active=True,
+        verified=False,
+        close_old_findings=None,
+        expected_http_status_code=201,
+    ):
+        """Helper method to perform reimport with dry_run=True"""
+        with Path(filename).open(encoding="utf-8") as testfile:
+            payload = {
+                "minimum_severity": minimum_severity,
+                "active": active,
+                "verified": verified,
+                "scan_type": scan_type,
+                "file": testfile,
+                "test": test_id,
+                "dry_run": True,  # This is the key parameter
+            }
+
+            if close_old_findings is not None:
+                payload["close_old_findings"] = close_old_findings
+
+            return self.reimport_scan(payload, expected_http_status_code)
+
+    def test_dry_run_basic_functionality(self):
+        """Test that dry_run returns analysis without making changes"""
+        logger.debug("Testing basic dry_run functionality")
+
+        # Import initial scan
+        with assertTestImportModelsCreated(self, imports=1, affected_findings=4, created=4):
+            import0 = self.import_scan_with_params(self.zap_sample0_filename)
+
+        test_id = import0["test"]
+
+        # Get initial state
+        initial_findings = self.get_test_findings_api(test_id)
+        initial_count = len(initial_findings["results"])
+
+        # Perform dry run reimport with different scan that would add findings
+        dry_run_result = self.reimport_scan_with_dry_run(test_id, self.zap_sample1_filename)
+
+        # Verify dry_run flag is in response
+        self.assertTrue(dry_run_result.get("dry_run", False), "Response should indicate dry_run mode")
+
+        # Verify changes_preview is present and contains expected structure
+        self.assertIn("changes_preview", dry_run_result, "Dry run should include changes preview")
+        changes = dry_run_result["changes_preview"]
+
+        # Verify expected change counts for zap_sample1 (should have 1 new finding)
+        self.assertEqual(changes["would_create"], 1, "Should predict 1 new finding")
+        self.assertEqual(changes["would_reactivate"], 0, "Should predict 0 reactivated findings")
+        self.assertEqual(changes["would_close"], 3, "Should predict 3 closed findings")  # 3 findings not in new scan
+        self.assertEqual(changes["would_leave_untouched"], 1, "Should predict 1 untouched finding")
+        self.assertEqual(changes["total_changes"], 2, "Total changes should be create + reactivate + close")
+
+        # Verify no actual changes were made to the database
+        post_dry_run_findings = self.get_test_findings_api(test_id)
+        post_dry_run_count = len(post_dry_run_findings["results"])
+
+        self.assertEqual(initial_count, post_dry_run_count, "Dry run should not change the actual number of findings")
+
+        # Verify individual findings remain unchanged
+        for initial_finding in initial_findings["results"]:
+            matching_finding = next(
+                (f for f in post_dry_run_findings["results"] if f["id"] == initial_finding["id"]), None
+            )
+            self.assertIsNotNone(matching_finding, f"Finding {initial_finding['id']} should still exist")
+            self.assertEqual(
+                initial_finding["active"],
+                matching_finding["active"],
+                "Finding active status should not change in dry run",
+            )
+            self.assertEqual(
+                initial_finding["mitigated"],
+                matching_finding["mitigated"],
+                "Finding mitigated status should not change in dry run",
+            )
+
+    def test_dry_run_with_close_old_findings_true(self):
+        """Test dry_run with close_old_findings=True predicts closing correctly"""
+        logger.debug("Testing dry_run with close_old_findings=True")
+
+        # Import initial scan
+        with assertTestImportModelsCreated(self, imports=1, affected_findings=4, created=4):
+            import0 = self.import_scan_with_params(self.zap_sample0_filename)
+
+        test_id = import0["test"]
+
+        # Dry run reimport with close_old_findings=True and scan that has different findings
+        dry_run_result = self.reimport_scan_with_dry_run(test_id, self.zap_sample1_filename, close_old_findings=True)
+
+        changes = dry_run_result["changes_preview"]
+
+        # With close_old_findings=True, findings not in new scan should be closed
+        self.assertEqual(changes["would_create"], 1, "Should predict 1 new finding")
+        self.assertEqual(changes["would_close"], 3, "Should predict 3 findings to be closed")
+        self.assertEqual(changes["would_leave_untouched"], 1, "Should predict 1 untouched finding")
+
+        # Verify no actual database changes
+        final_findings = self.get_test_findings_api(test_id)
+        active_findings = [f for f in final_findings["results"] if f["active"]]
+        self.assertEqual(len(active_findings), 4, "All original findings should still be active after dry run")
+
+    def test_dry_run_with_close_old_findings_false(self):
+        """Test dry_run with close_old_findings=False predicts no closing"""
+        logger.debug("Testing dry_run with close_old_findings=False")
+
+        # Import initial scan
+        with assertTestImportModelsCreated(self, imports=1, affected_findings=4, created=4):
+            import0 = self.import_scan_with_params(self.zap_sample0_filename)
+
+        test_id = import0["test"]
+
+        # Dry run reimport with close_old_findings=False
+        dry_run_result = self.reimport_scan_with_dry_run(test_id, self.zap_sample1_filename, close_old_findings=False)
+
+        changes = dry_run_result["changes_preview"]
+
+        # With close_old_findings=False, no findings should be closed
+        self.assertEqual(changes["would_create"], 1, "Should predict 1 new finding")
+        self.assertEqual(changes["would_close"], 0, "Should predict 0 findings to be closed")
+        self.assertEqual(changes["would_leave_untouched"], 4, "Should predict 4 untouched findings")
+
+    def test_dry_run_reactivation_prediction(self):
+        """Test that dry_run correctly predicts reactivation of mitigated findings"""
+        logger.debug("Testing dry_run reactivation prediction")
+
+        # Import initial scan with mitigated finding
+        with assertTestImportModelsCreated(self, imports=1, affected_findings=1, created=1):
+            import0 = self.import_scan_with_params(
+                self.veracode_mitigated_findings, scan_type=self.scan_type_veracode, verified=True
+            )
+
+        test_id = import0["test"]
+
+        # Verify the finding is mitigated
+        findings = self.get_test_findings_api(test_id)
+        mitigated_finding = findings["results"][0]
+        self.assertTrue(mitigated_finding["mitigated"], "Finding should be mitigated")
+
+        # Dry run reimport with same scan (finding exists and would be reactivated)
+        dry_run_result = self.reimport_scan_with_dry_run(
+            test_id,
+            self.veracode_many_findings,  # This scan has the same finding but active
+            scan_type=self.scan_type_veracode,
+        )
+
+        changes = dry_run_result["changes_preview"]
+
+        # Should predict reactivation of the mitigated finding
+        self.assertEqual(changes["would_reactivate"], 1, "Should predict 1 finding to be reactivated")
+        self.assertEqual(
+            changes["would_create"], 3, "Should predict 3 new findings"
+        )  # veracode_many has 4 total, 1 matches existing
+
+        # Verify no actual changes - finding should still be mitigated
+        post_dry_run_findings = self.get_test_findings_api(test_id)
+        post_dry_run_finding = post_dry_run_findings["results"][0]
+        self.assertTrue(post_dry_run_finding["mitigated"], "Finding should still be mitigated after dry run")
+
+    def test_dry_run_no_changes_scenario(self):
+        """Test dry_run when reimporting identical scan (no changes expected)"""
+        logger.debug("Testing dry_run with no changes scenario")
+
+        # Import initial scan
+        with assertTestImportModelsCreated(self, imports=1, affected_findings=4, created=4):
+            import0 = self.import_scan_with_params(self.zap_sample0_filename)
+
+        test_id = import0["test"]
+
+        # Dry run reimport with identical scan
+        dry_run_result = self.reimport_scan_with_dry_run(test_id, self.zap_sample0_filename)
+
+        changes = dry_run_result["changes_preview"]
+
+        # Should predict no changes
+        self.assertEqual(changes["would_create"], 0, "Should predict 0 new findings")
+        self.assertEqual(changes["would_reactivate"], 0, "Should predict 0 reactivated findings")
+        self.assertEqual(changes["would_close"], 0, "Should predict 0 closed findings")
+        self.assertEqual(changes["would_leave_untouched"], 4, "Should predict 4 untouched findings")
+        self.assertEqual(changes["total_changes"], 0, "Should predict 0 total changes")
+
+    def test_dry_run_severity_filtering(self):
+        """Test that dry_run respects minimum_severity filtering"""
+        logger.debug("Testing dry_run with severity filtering")
+
+        # Import initial scan with Low minimum severity
+        with assertTestImportModelsCreated(self, imports=1, affected_findings=4, created=4):
+            import0 = self.import_scan_with_params(self.zap_sample0_filename, minimum_severity="Low")
+
+        test_id = import0["test"]
+
+        # Dry run reimport with High minimum severity - should predict fewer findings
+        dry_run_result = self.reimport_scan_with_dry_run(
+            test_id,
+            self.zap_sample3_filename,  # Has findings with different severities
+            minimum_severity="High",
+        )
+
+        changes = dry_run_result["changes_preview"]
+
+        # The exact numbers depend on the scan content, but we should see some filtering effect
+        # This verifies that severity filtering is applied during dry run analysis
+        self.assertIsInstance(changes["would_create"], int, "Should return integer for would_create")
+        self.assertIsInstance(changes["would_close"], int, "Should return integer for would_close")
+
+        # Verify that dry run respects the minimum severity parameter
+        self.assertIn("changes_preview", dry_run_result, "Should include changes preview with severity filtering")
+
+    def test_dry_run_maintains_test_metadata(self):
+        """Test that dry_run doesn't modify test metadata like updated_time"""
+        logger.debug("Testing that dry_run preserves test metadata")
+
+        # Import initial scan
+        with assertTestImportModelsCreated(self, imports=1, affected_findings=4, created=4):
+            import0 = self.import_scan_with_params(self.zap_sample0_filename)
+
+        test_id = import0["test"]
+
+        # Get initial test metadata
+        initial_test = self.get_test_api(test_id)
+        initial_updated = initial_test["updated"]
+
+        # Perform dry run
+        dry_run_result = self.reimport_scan_with_dry_run(test_id, self.zap_sample1_filename)
+
+        # Verify dry run was successful
+        self.assertTrue(dry_run_result.get("dry_run", False))
+
+        # Check that test metadata wasn't modified
+        post_dry_run_test = self.get_test_api(test_id)
+        post_updated = post_dry_run_test["updated"]
+
+        self.assertEqual(initial_updated, post_updated, "Test updated timestamp should not change during dry run")
+
+    def test_dry_run_response_structure(self):
+        """Test that dry_run response has all expected fields"""
+        logger.debug("Testing dry_run response structure")
+
+        # Import initial scan
+        with assertTestImportModelsCreated(self, imports=1, affected_findings=4, created=4):
+            import0 = self.import_scan_with_params(self.zap_sample0_filename)
+
+        test_id = import0["test"]
+
+        # Perform dry run
+        dry_run_result = self.reimport_scan_with_dry_run(test_id, self.zap_sample1_filename)
+
+        # Verify required fields are present
+        self.assertIn("dry_run", dry_run_result, "Response should have dry_run field")
+        self.assertTrue(dry_run_result["dry_run"], "dry_run field should be True")
+
+        self.assertIn("changes_preview", dry_run_result, "Response should have changes_preview")
+
+        changes = dry_run_result["changes_preview"]
+        expected_fields = ["would_create", "would_reactivate", "would_close", "would_leave_untouched", "total_changes"]
+
+        for field in expected_fields:
+            self.assertIn(field, changes, f"changes_preview should contain {field}")
+            self.assertIsInstance(changes[field], int, f"{field} should be an integer")
+            self.assertGreaterEqual(changes[field], 0, f"{field} should be non-negative")
+
+        # Verify total_changes calculation
+        expected_total = changes["would_create"] + changes["would_reactivate"] + changes["would_close"]
+        self.assertEqual(
+            changes["total_changes"], expected_total, "total_changes should equal sum of create + reactivate + close"
+        )
+
+    def test_dry_run_with_different_scan_types(self):
+        """Test dry_run works with different scan types"""
+        logger.debug("Testing dry_run with Veracode scan type")
+
+        # Import initial Veracode scan
+        with assertTestImportModelsCreated(self, imports=1, affected_findings=4, created=4):
+            import0 = self.import_scan_with_params(self.veracode_many_findings, scan_type=self.scan_type_veracode)
+
+        test_id = import0["test"]
+
+        # Dry run reimport with same Veracode scan
+        dry_run_result = self.reimport_scan_with_dry_run(
+            test_id, self.veracode_many_findings, scan_type=self.scan_type_veracode
+        )
+
+        # Should work the same as with ZAP scans
+        self.assertTrue(dry_run_result.get("dry_run", False), "Should work with Veracode scans")
+        self.assertIn("changes_preview", dry_run_result, "Should include changes preview for Veracode")
+
+        changes = dry_run_result["changes_preview"]
+        # Identical scan should show no changes
+        self.assertEqual(changes["would_create"], 0, "Identical Veracode scan should show no new findings")
+        self.assertEqual(changes["would_leave_untouched"], 4, "Should show all findings as untouched")
+
+    def test_actual_reimport_after_dry_run_verification(self):
+        """Test that actual reimport after dry_run produces the predicted results"""
+        logger.debug("Testing that actual reimport matches dry_run predictions")
+
+        # Import initial scan
+        with assertTestImportModelsCreated(self, imports=1, affected_findings=4, created=4):
+            import0 = self.import_scan_with_params(self.zap_sample0_filename)
+
+        test_id = import0["test"]
+
+        # Perform dry run first
+        dry_run_result = self.reimport_scan_with_dry_run(test_id, self.zap_sample1_filename, close_old_findings=True)
+
+        predicted_changes = dry_run_result["changes_preview"]
+
+        # Now perform actual reimport with same parameters
+        with assertTestImportModelsCreated(self, reimports=1, affected_findings=4, created=1, closed=3, untouched=1):
+            actual_result = self.reimport_scan_with_params(test_id, self.zap_sample1_filename, close_old_findings=True)
+
+        # Compare predictions with actual results
+        # Note: The exact comparison depends on the specific scan files and their content
+        # This test verifies that dry_run provides accurate predictions
+
+        final_findings = self.get_test_findings_api(test_id)
+
+        # Verify the test was actually modified (unlike dry run)
+        self.assertFalse(actual_result.get("dry_run", False), "Actual reimport should not be dry run")
+
+        # Count actual changes
+        active_findings = [f for f in final_findings["results"] if f["active"]]
+        mitigated_findings = [f for f in final_findings["results"] if f["mitigated"]]
+
+        # The total number of findings should match: untouched + created = active findings
+        # closed findings should be mitigated
+        expected_active = predicted_changes["would_leave_untouched"] + predicted_changes["would_create"]
+        expected_mitigated = predicted_changes["would_close"]
+
+        self.assertEqual(
+            len(active_findings), expected_active, "Actual active findings should match dry run prediction"
+        )
+        self.assertEqual(
+            len(mitigated_findings), expected_mitigated, "Actual mitigated findings should match dry run prediction"
+        )