feat: add issue version in filter

- create a function to validate issue id and issue version for a issue
- pass issue versino in functions to validate build/test (tree and hardware)
- use formatter function to issue label
- send the issue version in frontend

Close #739

backend/kernelCI_app/helpers/commonDetails.py

@@ -5,6 +5,6 @@ def add_unfiltered_issue(
     *, issue_id, issue_version, should_increment, issue_set, is_invalid
 ):
     if issue_id is not None and issue_version is not None and should_increment:
-        issue_set.add(issue_id)
+        issue_set.add((issue_id, issue_version))
     elif is_invalid is True:
-        issue_set.add(UNKNOWN_STRING)
+        issue_set.add((UNKNOWN_STRING, None))

backend/kernelCI_app/helpers/filters.py

@@ -1,4 +1,4 @@
-from typing import Optional, Dict, List, Tuple, TypedDict, Literal, Any
+from typing import Optional, Dict, List, Tuple, TypedDict, Literal, Any, Union
 from django.http import HttpResponseBadRequest
 import re
 from kernelCI_app.typeModels.databases import PASS_STATUS, failure_status_list
@@ -48,13 +48,42 @@ def is_issue_from_build(*, issue_id: Optional[str], incident_test_id: Optional[s
     return is_possible_build_issue
 
 
-# TODO: consider issue_version in the filter
-def is_issue_filtered_out(issue_id: Optional[str], issue_filters: set) -> bool:
-    return issue_id not in issue_filters
+def verify_issue_in_filter(
+    issue_filter_data: Union[Dict, str],
+    issue_id: Optional[str],
+    issue_version: Optional[str]
+) -> bool:
+    is_unknown_issue = False
+    if issue_filter_data == UNKNOWN_STRING:
+        filter_issue_id = UNKNOWN_STRING
+        filter_issue_version = None
+        is_unknown_issue = True
+    else:
+        filter_issue_id, filter_issue_version = issue_filter_data
+
+    is_issue_id_in_filter = filter_issue_id == issue_id
+    is_issue_version_filter = is_unknown_issue or filter_issue_version == issue_version
+
+    return is_issue_id_in_filter and is_issue_version_filter
+
+
+def is_issue_filtered_out(
+    *,
+    issue_id: Optional[str],
+    issue_filters: set,
+    issue_version: Optional[str]
+) -> bool:
+    in_filter = any(verify_issue_in_filter(issue, issue_id, issue_version) for issue in issue_filters)
+    return not in_filter
 
 
 def should_filter_test_issue(
-    issue_filters: set, issue_id: Optional[str], incident_test_id: Optional[str], test_status: Optional[str]
+    *,
+    issue_filters: set,
+    issue_id: Optional[str],
+    issue_version: Optional[str],
+    incident_test_id: Optional[str],
+    test_status: Optional[str]
 ) -> bool:
     has_issue_filter = len(issue_filters) > 0
     if not has_issue_filter:
@@ -74,7 +103,11 @@ def should_filter_test_issue(
     if is_exclusively_build_issue_result:
         issue_id = UNKNOWN_STRING
 
-    is_issue_filtered_out_result = is_issue_filtered_out(issue_id, issue_filters)
+    is_issue_filtered_out_result = is_issue_filtered_out(
+        issue_id=issue_id,
+        issue_version=issue_version,
+        issue_filters=issue_filters
+    )
 
     return is_issue_filtered_out_result
 
@@ -83,8 +116,9 @@ def should_filter_build_issue(
     *,
     issue_filters: set,
     issue_id: Optional[str],
+    issue_version: Optional[str],
     incident_test_id: Optional[str],
-    build_valid: Optional[bool],
+    build_valid: Optional[bool]
 ) -> bool:
     has_issue_filter = len(issue_filters) > 0
     if not has_issue_filter:
@@ -104,7 +138,11 @@ def should_filter_build_issue(
     if is_exclusively_test_issue_result:
         issue_id = UNKNOWN_STRING
 
-    is_issue_filtered_out_result = is_issue_filtered_out(issue_id, issue_filters)
+    is_issue_filtered_out_result = is_issue_filtered_out(
+        issue_id=issue_id,
+        issue_version=issue_version,
+        issue_filters=issue_filters
+    )
 
     return is_issue_filtered_out_result
 
@@ -290,7 +328,15 @@ def _handle_build_duration(self, current_filter: ParsedFilter) -> None:
 
     def _handle_issues(self, current_filter: ParsedFilter) -> None:
         tab = current_filter["field"].split(".")[0]
-        self.filterIssues[tab].add(current_filter["value"])
+
+        filter_value = current_filter["value"]
+        if filter_value == UNKNOWN_STRING:
+            self.filterIssues[tab].add((UNKNOWN_STRING, None))
+        else:
+            issue_id, issue_version = filter_value.rsplit(",", 1)
+            issue_version = int(issue_version) if issue_version != "null" else None
+
+            self.filterIssues[tab].add((issue_id, issue_version))
 
     def _handle_platforms(self, current_filter: ParsedFilter) -> None:
         tab = current_filter["field"].split(".")[0]
@@ -410,6 +456,7 @@ def is_build_filtered_out(
         duration: Optional[int],
         valid: Optional[bool],
         issue_id: Optional[str],
+        issue_version: Optional[str],
         incident_test_id: Optional[str],
     ) -> bool:
         return (
@@ -436,8 +483,9 @@ def is_build_filtered_out(
                 should_filter_build_issue(
                     issue_filters=self.filterIssues["build"],
                     issue_id=issue_id,
+                    issue_version=issue_version,
                     incident_test_id=incident_test_id,
-                    build_valid=valid,
+                    build_valid=valid
                 )
             )
         )
@@ -493,6 +541,7 @@ def is_boot_filtered_out(
         status: Optional[str],
         duration: Optional[int],
         issue_id: Optional[str] = None,
+        issue_version: Optional[str] = None,
         incident_test_id: Optional[str] = "incident_test_id",
         platform: Optional[str] = None,
     ) -> bool:
@@ -517,7 +566,11 @@ def is_boot_filtered_out(
                 and (toIntOrDefault(duration, 0) < self.filterBootDurationMin)
             )
             or should_filter_test_issue(
-                self.filterIssues["boot"], issue_id, incident_test_id, status
+                issue_filters=self.filterIssues["boot"],
+                issue_id=issue_id,
+                issue_version=issue_version,
+                incident_test_id=incident_test_id,
+                test_status=status
             )
             or (
                 len(self.filterPlatforms["boot"]) > 0
@@ -535,6 +588,7 @@ def is_test_filtered_out(
         status: Optional[str],
         duration: Optional[int],
         issue_id: Optional[str] = None,
+        issue_version: Optional[str] = None,
         incident_test_id: Optional[str] = "incident_test_id",
         platform: Optional[str] = None,
     ) -> bool:
@@ -559,7 +613,11 @@ def is_test_filtered_out(
                 and (toIntOrDefault(duration, 0) < self.filterTestDurationMin)
             )
             or should_filter_test_issue(
-                self.filterIssues["test"], issue_id, incident_test_id, status
+                issue_filters=self.filterIssues["test"],
+                issue_id=issue_id,
+                issue_version=issue_version,
+                incident_test_id=incident_test_id,
+                test_status=status
             )
             or (
                 len(self.filterPlatforms["test"]) > 0

backend/kernelCI_app/helpers/hardwareDetails.py

@@ -746,6 +746,7 @@ def decide_if_is_build_in_filter(
         valid=build["valid"],
         duration=build["duration"],
         issue_id=build["issue_id"],
+        issue_version=build["issue_version"],
         incident_test_id=incident_test_id,
     )
     return is_build_not_processed and not is_build_filtered_out_result
@@ -764,6 +765,7 @@ def decide_if_is_test_in_filter(
     duration = record["duration"]
     path = record["path"]
     issue_id = record["incidents__issue__id"]
+    issue_version = record["incidents__issue__version"]
     incidents_test_id = record["incidents__test_id"]
     platform = env_misc_value_or_default(
         handle_environment_misc(record["environment_misc"])
@@ -775,6 +777,7 @@ def decide_if_is_test_in_filter(
             duration=duration,
             path=path,
             issue_id=issue_id,
+            issue_version=issue_version,
             incident_test_id=incidents_test_id,
             platform=platform,
         )
@@ -784,6 +787,7 @@ def decide_if_is_test_in_filter(
             duration=duration,
             path=path,
             issue_id=issue_id,
+            issue_version=issue_version,
             incident_test_id=incidents_test_id,
             platform=platform,
         )

backend/kernelCI_app/helpers/treeDetails.py

@@ -378,6 +378,7 @@ def process_boots_issue(instance, row_data):
 
 def decide_if_is_build_filtered_out(instance, row_data):
     issue_id = row_data["issue_id"]
+    issue_version = row_data["issue_version"]
     build_valid = row_data["build_valid"]
     build_duration = row_data["build_duration"]
     incident_test_id = row_data["incident_test_id"]
@@ -386,6 +387,7 @@ def decide_if_is_build_filtered_out(instance, row_data):
         valid=build_valid,
         duration=build_duration,
         issue_id=issue_id,
+        issue_version=issue_version,
         incident_test_id=incident_test_id,
     )
     return is_build_filtered_out
@@ -395,12 +397,14 @@ def decide_if_is_boot_filtered_out(instance, row_data):
     test_status = row_data["test_status"]
     test_duration = row_data["test_duration"]
     issue_id = row_data["issue_id"]
+    issue_version = row_data["issue_version"]
     test_path = row_data["test_path"]
     incident_test_id = row_data["incident_test_id"]
 
     return instance.filters.is_boot_filtered_out(
         duration=test_duration,
         issue_id=issue_id,
+        issue_version=issue_version,
         path=test_path,
         status=test_status,
         incident_test_id=incident_test_id,

backend/kernelCI_app/unitTests/treeDetails.test.py

@@ -7,23 +7,34 @@ class TestShouldFilterTestIssue(unittest.TestCase):
 
     def test_no_issue_filters(self):
         self.assertFalse(
-            should_filter_test_issue(set(), UNKNOWN_STRING, "incident_test_1", "FAIL")
+            should_filter_test_issue(
+                issue_filters=set(),
+                issue_id=UNKNOWN_STRING,
+                issue_version=None,
+                incident_test_id="incident_test_1",
+                test_status="FAIL"
+            )
         )
 
     def test_unknown_filter_with_exclusively_build_issue(self):
         self.assertTrue(
             should_filter_test_issue(
-                {UNKNOWN_STRING}, "issue1", "incident_test_1", "PASS"
+                issue_filters={UNKNOWN_STRING},
+                issue_id="issue1",
+                issue_version="1",
+                incident_test_id="incident_test_1",
+                test_status="PASS"
             )
         )
 
     def test_unknown_issue_but_not_from_test(self):
         self.assertFalse(
             should_filter_test_issue(
-                {UNKNOWN_STRING},
-                "maestro:72697a4efbbd0eff7080781839b405bbf0902f79",
-                None,
-                "FAIL",
+                issue_filters={UNKNOWN_STRING},
+                issue_id="maestro:72697a4efbbd0eff7080781839b405bbf0902f79",
+                issue_version='0',
+                incident_test_id=None,
+                test_status="FAIL",
             )
         )