argus-alm 0.12.3__py3-none-any.whl → 0.12.4b1__py3-none-any.whl

argus/backend/service/argus_service.py

@@ -1,3 +1,5 @@
+from math import ceil
+from dataclasses import dataclass
 import subprocess
 import json
 import logging
@@ -25,9 +27,20 @@ from argus.backend.models.web import (
 )
 from argus.backend.events.event_processors import EVENT_PROCESSORS
 from argus.backend.service.testrun import TestRunService
+from argus.backend.util.common import chunk
 
 LOGGER = logging.getLogger(__name__)
 
+@dataclass(init=True, frozen=True)
+class ScheduleUpdateRequest:
+    release_id: UUID
+    schedule_id: UUID
+    assignee: UUID
+    new_tests: list[UUID]
+    old_tests: list[UUID]
+    comments: dict[UUID, str]
+
+
 
 class ArgusService:
     # pylint: disable=no-self-use,too-many-arguments,too-many-instance-attributes,too-many-locals, too-many-public-methods
@@ -233,7 +246,7 @@ class ArgusService:
                 row.save()
 
     def submit_new_schedule(self, release: str | UUID, start_time: str, end_time: str, tests: list[str | UUID],
-                            groups: list[str | UUID], assignees: list[str | UUID], tag: str) -> dict:
+                            groups: list[str | UUID], assignees: list[str | UUID], tag: str, comments: dict[str, str] | None, group_ids: dict[str, str] | None) -> dict:
         release = UUID(release) if isinstance(release, str) else release
         if len(assignees) == 0:
             raise Exception("Assignees not specified in the new schedule")
@@ -283,6 +296,19 @@ class ArgusService:
             assignee_entity.save()
             response["assignees"].append(assignee_id)
 
+        if comments:
+            for test_id, new_comment in comments.items():
+                try:
+                    comment = ReleasePlannerComment.get(release=release, group=group_ids[test_id], test=test_id)
+                except ReleasePlannerComment.DoesNotExist:
+                    comment = ReleasePlannerComment()
+                    comment.release = release
+                    comment.group = group_ids[test_id]
+                    comment.test = test_id
+
+                comment.comment = new_comment
+                comment.save()
+
         return response
 
     def get_schedules_for_release(self, release_id: str | UUID) -> dict:
@@ -397,11 +423,52 @@ class ArgusService:
             "newComment": new_comment,
         }
 
+    def update_schedule(self, release_id: UUID | str, schedule_id: UUID | str, old_tests: list[UUID | str], new_tests: list[UUID | str], comments: dict[str, str], assignee: UUID | str):
+        schedule: ArgusSchedule = ArgusSchedule.get(release_id=release_id, id=schedule_id)
+        new_tests: set[UUID] = {UUID(id) for id in new_tests}
+        old_tests: set[UUID] = {UUID(id) for id in old_tests}
+
+        all_test_ids = old_tests.union(new_tests)
+        tests = []
+        for batch in chunk(all_test_ids):
+            tests.extend(ArgusTest.filter(id__in=batch).all())
+        tests_by_id: dict[UUID, ArgusTest] = { test.id: test for test in tests }
+
+        all_scheduled_tests: list[ArgusScheduleTest] = list(ArgusScheduleTest.filter(schedule_id=schedule_id).all())
+        tests_to_remove = all_test_ids.difference(new_tests)
+        for scheduled_test in all_scheduled_tests:
+            if scheduled_test.test_id in tests_to_remove:
+                test = tests_by_id.get(scheduled_test.test_id)
+                scheduled_test.delete()
+                if test:
+                    self.update_schedule_comment({"newComment": "", "releaseId": test.release_id, "groupId": test.group_id, "testId": test.id})
+
+        tests_to_add = new_tests.difference(old_tests)
+        for test_id in tests_to_add:
+            entity = ArgusScheduleTest()
+            entity.id = uuid_from_time(schedule.period_start)
+            entity.schedule_id = schedule.id
+            entity.test_id = UUID(test_id) if isinstance(test_id, str) else test_id
+            entity.release_id = release_id
+            entity.save()
+            self.assign_runs_for_scheduled_test(schedule, entity.test_id, assignee)
+
+        for test_id, comment in comments.items():
+            test = tests_by_id.get(UUID(test_id))
+            if test:
+                self.update_schedule_comment({"newComment": comment, "releaseId": test.release_id, "groupId": test.group_id, "testId": test.id})
+
+        schedule_assignee: ArgusScheduleAssignee = ArgusScheduleAssignee.get(schedule_id=schedule_id)
+        schedule_assignee.assignee = assignee
+        schedule_assignee.save()
+        return True
+
     def delete_schedule(self, payload: dict) -> dict:
         """
         {
             "release": hex-uuid,
-            "schedule_id": uuid1
+            "schedule_id": uuid1,
+            "deleteComments": bool
         }
         """
         release_id = payload.get("releaseId")
@@ -412,6 +479,8 @@ class ArgusService:
         if not schedule_id:
             raise Exception("Schedule id not specified in the request")
 
+        delete_comments = payload.get("deleteComments", False)
+
         release = ArgusRelease.get(id=release_id)
         schedule = ArgusSchedule.get(release_id=release.id, id=schedule_id)
         tests = ArgusScheduleTest.filter(schedule_id=schedule.id).all()
@@ -441,6 +510,15 @@ class ArgusService:
                 entity.delete()
 
         schedule.delete()
+
+        if delete_comments:
+            tests = []
+            for batch in chunk(full_schedule["tests"]):
+                tests.extend(ArgusTest.filter(id__in=batch).all())
+
+            for test in tests:
+                self.update_schedule_comment({"newComment": "", "releaseId": test.release_id, "groupId": test.group_id, "testId": test.id})
+
         return {
             "releaseId": release.id,
             "scheduleId": schedule_id,
@@ -480,6 +558,15 @@ class ArgusService:
 
         return response
 
+    def _batch_get_schedules_from_ids(self, release_id: UUID, schedule_ids: list[UUID]) -> list[ArgusSchedule]:
+        schedules = []
+        step_size = 90
+        for step in range(0, ceil(len(schedule_ids) / step_size)):
+            start_pos = step*step_size
+            next_slice = schedule_ids[start_pos:start_pos+step_size]
+            schedules.extend(ArgusSchedule.filter(release_id=release_id, id__in=next_slice).all())
+        return schedules
+
     def get_groups_assignees(self, release_id: UUID | str):
         release_id = UUID(release_id) if isinstance(release_id, str) else release_id
         release = ArgusRelease.get(id=release_id)
@@ -487,19 +574,19 @@ class ArgusService:
         groups = ArgusGroup.filter(release_id=release_id).all()
         group_ids = [group.id for group in groups if group.enabled]
 
-        total_ids = len(group_ids)
         schedule_ids = set()
-        step = 0
-        step_size = 60
-        while total_ids > 0:
-            group_slice = group_ids[step:step+step_size]
-            scheduled_groups = ArgusScheduleGroup.filter(release_id=release.id, group_id__in=group_slice).all()
-            batch_ids = {schedule.schedule_id for schedule in scheduled_groups}
-            schedule_ids.union(batch_ids)
-            total_ids = max(0, total_ids - step_size)
-            step += step_size
-
-        schedules = ArgusSchedule.filter(release_id=release.id, id__in=tuple(schedule_ids)).all()
+        group_schedules =[]
+        step_size = 90
+
+        for step in range(0, ceil(len(group_ids) / step_size)):
+            start_pos = step*step_size
+            next_slice = group_ids[start_pos:start_pos+step_size]
+            group_batch = list(ArgusScheduleGroup.filter(release_id=release.id, group_id__in=next_slice).all())
+            group_schedules.extend(group_batch)
+            batch_ids = {schedule.schedule_id for schedule in group_batch}
+            schedule_ids = schedule_ids.union(batch_ids)
+
+        schedules = self._batch_get_schedules_from_ids(release.id, list(schedule_ids))
 
         valid_schedules = schedules
         if release.perpetual:
@@ -510,7 +597,7 @@ class ArgusService:
         for schedule in valid_schedules:
             assignees = ArgusScheduleAssignee.filter(schedule_id=schedule.id).all()
             assignees_uuids = [assignee.assignee for assignee in assignees]
-            schedule_groups = filter(lambda g: g.schedule_id == schedule.id, scheduled_groups)
+            schedule_groups = filter(lambda g: g.schedule_id == schedule.id, group_schedules)
             groups = {str(group.group_id): assignees_uuids for group in schedule_groups}
             response = {**groups, **response}
 
@@ -525,10 +612,19 @@ class ArgusService:
 
         test_ids = [test.id for test in tests if test.enabled]
 
-        scheduled_tests = ArgusScheduleTest.filter(release_id=release.id, test_id__in=tuple(test_ids)).all()
-        schedule_ids = {test.schedule_id for test in scheduled_tests}
-        schedules: list[ArgusSchedule] = list(ArgusSchedule.filter(
-            release_id=release.id, id__in=tuple(schedule_ids)).all())
+        schedule_ids = set()
+        test_schedules = []
+        step_size = 90
+
+        for step in range(0, ceil(len(test_ids) / step_size)):
+            start_pos = step*step_size
+            next_slice = test_ids[start_pos:start_pos+step_size]
+            test_batch = ArgusScheduleTest.filter(release_id=release.id, test_id__in=next_slice).all()
+            test_schedules.extend(test_batch)
+            batch_ids = {schedule.schedule_id for schedule in test_batch}
+            schedule_ids = schedule_ids.union(batch_ids)
+
+        schedules = self._batch_get_schedules_from_ids(release.id, list(schedule_ids))
 
         if release.perpetual:
             today = datetime.datetime.utcnow()
@@ -538,7 +634,7 @@ class ArgusService:
         for schedule in schedules:
             assignees = ArgusScheduleAssignee.filter(schedule_id=schedule.id).all()
             assignees_uuids = [assignee.assignee for assignee in assignees]
-            schedule_tests = filter(lambda t: t.schedule_id == schedule.id, scheduled_tests)
+            schedule_tests = filter(lambda t: t.schedule_id == schedule.id, test_schedules)
             tests = {str(test.test_id): assignees_uuids for test in schedule_tests}
             response = {**tests, **response}
 

argus/backend/service/build_system_monitor.py

@@ -2,23 +2,28 @@ import logging
 from abc import ABC, abstractmethod
 import jenkins
 import click
+import re
 from flask import current_app
 from flask.cli import with_appcontext
 
 from argus.backend.db import ScyllaCluster
-from argus.backend.models.web import ArgusRelease, ArgusGroup, ArgusTest
+from argus.backend.models.web import ArgusRelease, ArgusGroup, ArgusTest, ArgusTestException
 from argus.backend.service.release_manager import ReleaseManagerService
 
 LOGGER = logging.getLogger(__name__)
 
 
 class ArgusTestsMonitor(ABC):
+    BUILD_SYSTEM_FILTERED_PREFIXES = [
+
+    ]
+
     def __init__(self) -> None:
         self._cluster = ScyllaCluster.get()
         self._existing_releases = list(ArgusRelease.all())
         self._existing_groups = list(ArgusGroup.all())
         self._existing_tests = list(ArgusTest.all())
-        self._filtered_groups: list[str] = current_app.config["BUILD_SYSTEM_FILTERED_PREFIXES"]
+        self._filtered_groups: list[str] = self.BUILD_SYSTEM_FILTERED_PREFIXES
 
     def create_release(self, release_name):
         # pylint: disable=no-self-use
@@ -68,17 +73,39 @@ class ArgusTestsMonitor(ABC):
 
 
 class JenkinsMonitor(ArgusTestsMonitor):
+
+    BUILD_SYSTEM_FILTERED_PREFIXES = [
+        "releng",
+    ]
+
+    JENKINS_MONITORED_RELEASES = [
+        r"^scylla-master$",
+        r"^scylla-staging$",
+        r"^scylla-\d+\.\d+$",
+        r"^manager-3.\d+$",
+        r"^scylla-operator/operator-master$",
+        r"^scylla-operator/operator-\d+.\d+$",
+        r"^scylla-enterprise$",
+        r"^enterprise-20\d{2}\.\d+$",
+        r"^siren-tests$",
+    ]
+
     def __init__(self) -> None:
         super().__init__()
         self._jenkins = jenkins.Jenkins(url=current_app.config["JENKINS_URL"],
                                         username=current_app.config["JENKINS_USER"],
                                         password=current_app.config["JENKINS_API_TOKEN"])
-        self._monitored_releases = current_app.config["JENKINS_MONITORED_RELEASES"]
+        self._monitored_releases = self.JENKINS_MONITORED_RELEASES
+
+    def _check_release_name(self, release_name: str):
+        return any(re.match(pattern, release_name, re.IGNORECASE) for pattern in self._monitored_releases)
 
     def collect(self):
         click.echo("Collecting new tests from jenkins")
         all_jobs = self._jenkins.get_all_jobs()
-        all_monitored_folders = [job for job in all_jobs if job["fullname"] in self._monitored_releases]
+        all_monitored_folders = [job for job in all_jobs if self._check_release_name(job["fullname"])]
+        LOGGER.info("Will collect %s", [f["fullname"] for f in all_monitored_folders])
+
         for release in all_monitored_folders:
             LOGGER.info("Processing release %s", release["name"])
             try:
@@ -143,9 +170,12 @@ class JenkinsMonitor(ArgusTestsMonitor):
                         except StopIteration:
                             LOGGER.warning("Test %s for release %s (group %s) doesn't exist, creating...",
                                            job["name"], saved_release.name, saved_group.name)
-                            saved_test = self.create_test(
-                                saved_release, saved_group, job["name"], job["fullname"], job["url"])
-                            self._existing_tests.append(saved_test)
+                            try:
+                                saved_test = self.create_test(
+                                    saved_release, saved_group, job["name"], job["fullname"], job["url"])
+                                self._existing_tests.append(saved_test)
+                            except ArgusTestException:
+                                LOGGER.error("Unable to create test for build_id %s", job["fullname"], exc_info=True)
 
     def collect_groups_for_release(self, jobs):
         # pylint: disable=no-self-use

argus/backend/service/jenkins_service.py

@@ -195,7 +195,8 @@ class JenkinsService:
         LOGGER.info(old_config)
         xml = ET.fromstring(old_config)
         display_name = xml.find("displayName")
-        display_name.text = new_name
+        if display_name:
+            display_name.text = new_name
         new_config = ET.tostring(xml, encoding="unicode")
         self._jenkins.create_job(name=jenkins_new_build_id, config_xml=new_config)
         new_job_info = self._jenkins.get_job_info(name=jenkins_new_build_id)

argus/backend/service/release_manager.py

@@ -44,6 +44,20 @@ class ReleaseManagerService:
     def get_tests(self, group_id: UUID) -> list[ArgusTest]:
         return list(ArgusTest.filter(group_id=group_id).all())
 
+    def toggle_test_enabled(self, test_id: UUID, new_state: bool) -> bool:
+        test: ArgusTest = ArgusTest.get(id=test_id)
+        test.enabled = new_state
+        test.save()
+
+        return test
+
+    def toggle_group_enabled(self, group_id: UUID, new_state: bool) -> bool:
+        test: ArgusGroup = ArgusGroup.get(id=group_id)
+        test.enabled = new_state
+        test.save()
+
+        return test
+
     def create_release(self, release_name: str, pretty_name: str, perpetual: bool) -> ArgusRelease:
         try:
             release = ArgusRelease.get(name=release_name)

argus/backend/service/stats.py

@@ -6,11 +6,12 @@ from datetime import datetime
 from typing import TypedDict
 from uuid import UUID
 
+from cassandra.cqlengine.models import Model
 from argus.backend.plugins.loader import all_plugin_models
-from argus.backend.util.common import get_build_number
+from argus.backend.util.common import chunk, get_build_number
 from argus.backend.util.enums import TestStatus, TestInvestigationStatus
 from argus.backend.models.web import ArgusGithubIssue, ArgusRelease, ArgusGroup, ArgusTest,\
-    ArgusScheduleTest, ArgusTestRunComment
+    ArgusScheduleTest, ArgusTestRunComment, ArgusUserView
 from argus.backend.db import ScyllaCluster
 
 LOGGER = logging.getLogger(__name__)
@@ -142,6 +143,96 @@ def generate_field_status_map(
                 status_map[run_number] = (run[field_name], run)
     return status_map
 
+class ViewStats:
+    def __init__(self, release: ArgusUserView) -> None:
+        self.release = release
+        self.groups: list[GroupStats] = []
+        self.status_map = {status: 0 for status in TestStatus}
+        self.total_tests = 0
+        self.last_status = TestStatus.NOT_PLANNED
+        self.last_investigation_status = TestInvestigationStatus.NOT_INVESTIGATED
+        self.has_bug_report = False
+        self.issues: list[ArgusGithubIssue] = []
+        self.comments: list[ArgusTestRunComment] = []
+        self.test_schedules: dict[UUID, ArgusScheduleTest] = {}
+        self.forced_collection = False
+        self.rows = []
+        self.releases = {}
+        self.all_tests = []
+
+    def to_dict(self) -> dict:
+        converted_groups = {str(group.group.id): group.to_dict() for group in self.groups}
+        aggregated_investigation_status = {}
+        for group in converted_groups.values():
+            for investigation_status in TestInvestigationStatus:
+                current_status = aggregated_investigation_status.get(investigation_status.value, {})
+                result = {
+                    status.value: current_status.get(status.value, 0) + group.get(investigation_status.value, {}).get(status, 0)
+                    for status in TestStatus
+                }
+                aggregated_investigation_status[investigation_status.value] = result
+
+        return {
+            "release": dict(self.release.items()),
+            "releases": self.releases,
+            "groups": converted_groups,
+            "total": self.total_tests,
+            **self.status_map,
+            "disabled": False,
+            "perpetual": False,
+            "lastStatus": self.last_investigation_status,
+            "lastInvestigationStatus": self.last_investigation_status,
+            "hasBugReport": self.has_bug_report,
+            **aggregated_investigation_status
+        }
+
+    def _fetch_multiple_release_queries(self, entity: Model, releases: list[str]):
+        result_set = []
+        for release_id in releases:
+            result_set.extend(entity.filter(release_id=release_id).all())
+        return result_set
+
+    def collect(self, rows: list[TestRunStatRow], limited=False, force=False, dict: dict[str, TestRunStatRow] | None = None, tests: list[ArgusTest] = None) -> None:
+        self.forced_collection = force
+        all_release_ids = list({t.release_id for t in tests})
+        if not limited:
+            self.test_schedules = reduce(
+                lambda acc, row: acc[row["test_id"]].append(row) or acc,
+                self._fetch_multiple_release_queries(ArgusScheduleTest, all_release_ids),
+                defaultdict(list)
+            )
+
+        self.rows = rows
+        self.dict = dict
+        if not limited or force:
+            self.issues = reduce(
+                lambda acc, row: acc[row["run_id"]].append(row) or acc,
+                self._fetch_multiple_release_queries(ArgusGithubIssue, all_release_ids),
+                defaultdict(list)
+            )
+            self.comments = reduce(
+                lambda acc, row: acc[row["test_run_id"]].append(row) or acc,
+                self._fetch_multiple_release_queries(ArgusTestRunComment, all_release_ids),
+                defaultdict(list)
+            )
+        self.all_tests = tests
+        groups = []
+        for slice in chunk(list({t.release_id for t in tests})):
+            self.releases.update({str(release.id): release for release in ArgusRelease.filter(id__in=slice).all()})
+
+        for slice in chunk(list({t.group_id for t in tests})):
+            groups.extend(ArgusGroup.filter(id__in=slice).all())
+        for group in groups:
+            if group.enabled:
+                stats = GroupStats(group=group, parent_release=self)
+                stats.collect(limited=limited)
+                self.groups.append(stats)
+
+    def increment_status(self, status=TestStatus.NOT_PLANNED):
+        self.total_tests += 1
+        self.status_map[TestStatus(status)] += 1
+        self.last_status = TestStatus(status)
+
 
 class ReleaseStats:
     def __init__(self, release: ArgusRelease) -> None:
@@ -154,7 +245,7 @@ class ReleaseStats:
         self.has_bug_report = False
         self.issues: list[ArgusGithubIssue] = []
         self.comments: list[ArgusTestRunComment] = []
-        self.test_schedules: list[ArgusScheduleTest] = []
+        self.test_schedules: dict[UUID, ArgusScheduleTest] = {}
         self.forced_collection = False
         self.rows = []
         self.all_tests = []
@@ -190,9 +281,11 @@ class ReleaseStats:
             return
 
         if not self.release.perpetual and not limited:
-            self.test_schedules = list(ArgusScheduleTest.filter(
-                release_id=self.release.id
-            ).all())
+            self.test_schedules = reduce(
+                lambda acc, row: acc[row["test_id"]].append(row) or acc,
+                ArgusScheduleTest.filter(release_id=self.release.id).all(), 
+                defaultdict(list)
+            )
 
         self.rows = rows
         self.dict = dict
@@ -261,8 +354,7 @@ class GroupStats:
                 stats = TestStats(
                     test=test,
                     parent_group=self,
-                    schedules=tuple(
-                        schedule for schedule in self.parent_release.test_schedules if schedule.test_id == test.id)
+                    schedules=self.parent_release.test_schedules.get(test.id, [])
                 )
                 stats.collect(limited=limited)
                 self.tests.append(stats)
@@ -371,10 +463,10 @@ class ReleaseStatsCollector:
 
     def collect(self, limited=False, force=False, include_no_version=False) -> dict:
         self.release: ArgusRelease = ArgusRelease.get(name=self.release_name)
-        all_tests = ArgusTest.filter(release_id=self.release.id).all()
-        build_ids = [t.build_system_id for t in all_tests]
+        all_tests: list[ArgusTest] = list(ArgusTest.filter(release_id=self.release.id).all())
+        build_ids = reduce(lambda acc, test: acc[test.plugin_name or "unknown"].append(test.build_system_id) or acc, all_tests, defaultdict(list))
         self.release_rows = [futures for plugin in all_plugin_models()
-                             for futures in plugin.get_stats_for_release(release=self.release, build_ids=build_ids)]
+                             for futures in plugin.get_stats_for_release(release=self.release, build_ids=build_ids.get(plugin._plugin_name, []))]
         self.release_rows = [row for future in self.release_rows for row in future.result()]
         if self.release.dormant and not force:
             return {
@@ -402,3 +494,47 @@ class ReleaseStatsCollector:
         self.release_stats = ReleaseStats(release=self.release)
         self.release_stats.collect(rows=self.release_rows, limited=limited, force=force, dict=self.release_dict, tests=all_tests)
         return self.release_stats.to_dict()
+
+
+class ViewStatsCollector:
+    def __init__(self, view_id: UUID, filter: str | None = None) -> None:
+        self.database = ScyllaCluster.get()
+        self.session = self.database.get_session()
+        self.view = None
+        self.view_stats = None
+        self.view_rows = []
+        self.runs_by_build_id = {}
+        self.view_id = view_id
+        self.filter = filter
+
+    def collect(self, limited=False, force=False, include_no_version=False) -> dict:
+        self.view: ArgusUserView = ArgusUserView.get(id=self.view_id)
+        all_tests: list[ArgusTest] = []
+        for slice in chunk(self.view.tests):
+            all_tests.extend(ArgusTest.filter(id__in=slice).all())
+        build_ids = reduce(lambda acc, test: acc[test.plugin_name or "unknown"].append(test.build_system_id) or acc, all_tests, defaultdict(list))
+        self.view_rows = [futures for plugin in all_plugin_models()
+                             for futures in plugin.get_stats_for_release(release=self.view, build_ids=build_ids.get(plugin._plugin_name, []))]
+        self.view_rows = [row for future in self.view_rows for row in future.result()]
+
+        if self.filter:
+            if include_no_version:
+                expr = lambda row: row["scylla_version"] == self.filter or not row["scylla_version"] 
+            elif self.filter == "!noVersion":
+                expr = lambda row: not row["scylla_version"]
+            else:
+                expr = lambda row: row["scylla_version"] == self.filter
+        else:
+            if include_no_version:
+                expr = lambda row: row
+            else:
+                expr = lambda row: row["scylla_version"]
+        self.view_rows = list(filter(expr, self.view_rows))
+        for row in self.view_rows:
+            runs = self.runs_by_build_id.get(row["build_id"], [])
+            runs.append(row)
+            self.runs_by_build_id[row["build_id"]] = runs
+
+        self.view_stats = ViewStats(release=self.view)
+        self.view_stats.collect(rows=self.view_rows, limited=limited, force=force, dict=self.runs_by_build_id, tests=all_tests)
+        return self.view_stats.to_dict()

argus/backend/service/testrun.py

@@ -1,4 +1,6 @@
+from collections import defaultdict
 from datetime import datetime, timedelta
+from functools import reduce
 import json
 import logging
 import re
@@ -22,6 +24,7 @@ from argus.backend.models.web import (
     ArgusRelease,
     ArgusTest,
     ArgusTestRunComment,
+    ArgusUserView,
     User,
     UserOauthToken,
 )
@@ -33,7 +36,7 @@ from argus.backend.events.event_processors import EVENT_PROCESSORS
 from argus.backend.service.event_service import EventService
 from argus.backend.service.notification_manager import NotificationManagerService
 from argus.backend.service.stats import ComparableTestStatus
-from argus.backend.util.common import get_build_number, strip_html_tags
+from argus.backend.util.common import chunk, get_build_number, strip_html_tags
 from argus.backend.util.enums import TestInvestigationStatus, TestStatus
 
 LOGGER = logging.getLogger(__name__)
@@ -163,6 +166,12 @@ class TestRunService:
     def change_run_assignee(self, test_id: UUID, run_id: UUID, new_assignee: UUID | None):
         test = ArgusTest.get(id=test_id)
         plugin = self.get_plugin(plugin_name=test.plugin_name)
+        if not plugin:
+            return {
+                "test_run_id": run.id,
+                "assignee": None
+            }
+
         run: PluginModelBase = plugin.model.get(id=run_id)
         old_assignee = run.assignee
         run.assignee = new_assignee
@@ -219,6 +228,7 @@ class TestRunService:
         plugin = self.get_plugin(test.plugin_name)
         release: ArgusRelease = ArgusRelease.get(id=test.release_id)
         comment = ArgusTestRunComment()
+        comment.test_id = test.id
         comment.message = message_stripped
         comment.reactions = reactions
         comment.mentions = [m.id for m in mentions]
@@ -374,13 +384,23 @@ class TestRunService:
 
         return response
 
+    def _get_github_issues_for_view(self, view_id: UUID | str) -> list[ArgusGithubIssue]:
+        view: ArgusUserView = ArgusUserView.get(id=view_id)
+        issues = []
+        for batch in chunk(view.tests):
+            issues.extend(ArgusGithubIssue.filter(test_id__in=batch).allow_filtering().all())
+        
+        return issues
+
     def get_github_issues(self, filter_key: str, filter_id: UUID, aggregate_by_issue: bool = False) -> dict:
-        if filter_key not in ["release_id", "group_id", "test_id", "run_id", "user_id"]:
+        if filter_key not in ["release_id", "group_id", "test_id", "run_id", "user_id", "view_id"]:
             raise Exception(
-                "filter_key can only be one of: \"release_id\", \"group_id\", \"test_id\", \"run_id\", \"user_id\""
+                "filter_key can only be one of: \"release_id\", \"group_id\", \"test_id\", \"run_id\", \"user_id\", \"view_id\""
             )
-
-        all_issues = ArgusGithubIssue.filter(**{filter_key: filter_id}).all()
+        if filter_key == "view_id":
+            all_issues = self._get_github_issues_for_view(filter_id)
+        else:
+            all_issues = ArgusGithubIssue.filter(**{filter_key: filter_id}).all()
         if aggregate_by_issue:
             runs_by_issue = {}
             response = []
@@ -398,6 +418,25 @@ class TestRunService:
             response = [dict(issue.items()) for issue in all_issues]
         return response
 
+    def resolve_run_build_id_and_number_multiple(self, runs: list[tuple[UUID, UUID]]) -> dict[UUID, dict[str, Any]]:
+        test_ids = [r[0] for r in runs]
+        all_tests: list = []
+        for id_slice in chunk(test_ids):
+            all_tests.extend(ArgusTest.filter(id__in=id_slice).all())
+
+        tests: dict[str, ArgusTest] = {str(t.id): t for t in all_tests}
+        runs_by_plugin = reduce(lambda acc, val: acc[tests[val[0]].plugin_name].append(val[1]) or acc, runs, defaultdict(list))
+        all_runs = {}
+        for plugin, run_ids in runs_by_plugin.items():
+            model = AVAILABLE_PLUGINS.get(plugin).model
+            model_runs = []
+            for run_id in run_ids:
+                model_runs.append(model.filter(id=run_id).only(["build_id", "start_time", "build_job_url", "id", "test_id"]).get())
+            all_runs.update({ str(run["id"]): {**run, "build_number": get_build_number(run["build_job_url"])} for run in model_runs })
+
+        return all_runs
+
+
     def delete_github_issue(self, issue_id: UUID) -> dict:
         issue: ArgusGithubIssue = ArgusGithubIssue.get(id=issue_id)