argus-alm 0.12.4b2__py3-none-any.whl → 0.12.5__py3-none-any.whl

argus/backend/controller/client_api.py

@@ -90,3 +90,14 @@ def run_finalize(run_type: str, run_id: str):
         "status": "ok",
         "response": result
     }
+
+
+@bp.route("/testrun/<string:run_type>/<string:run_id>/submit_results", methods=["POST"])
+@api_login_required
+def submit_results(run_type: str, run_id: str):
+    payload = get_payload(request)
+    result = ClientService().submit_results(run_type=run_type, run_id=run_id, results=payload)
+    return {
+        "status": "ok",
+        "response": result
+    }

argus/backend/controller/testrun_api.py

@@ -63,6 +63,17 @@ def test_run_activity(run_id: str):
     }
 
 
+
+@bp.route("/run/<string:test_id>/<string:run_id>/fetch_results", methods=["GET"])
+@api_login_required
+def fetch_results(test_id: str, run_id: str):
+    tables = TestRunService().fetch_results(test_id=UUID(test_id), run_id=UUID(run_id))
+    return {
+        "status": "ok",
+        "tables": tables
+    }
+
+
 @bp.route("/test/<string:test_id>/run/<string:run_id>/status/set", methods=["POST"])
 @api_login_required
 def set_testrun_status(test_id: str, run_id: str):

argus/backend/models/result.py

@@ -0,0 +1,41 @@
+from cassandra.cqlengine import columns
+from cassandra.cqlengine.models import Model
+from cassandra.cqlengine.usertype import UserType
+from enum import Enum
+
+
+class Status(Enum):
+    PASS = 0
+    WARNING = 1
+    ERROR = 2
+
+
+class ColumnMetadata(UserType):
+    name = columns.Ascii()
+    unit = columns.Text()
+    type = columns.Ascii()
+
+
+class ArgusGenericResultMetadata(Model):
+    __table_name__ = "generic_result_metadata_v1"
+    test_id = columns.UUID(partition_key=True)
+    name = columns.Text(required=True, primary_key=True)
+    description = columns.Text()
+    columns_meta = columns.List(value_type=columns.UserDefinedType(ColumnMetadata))
+    rows_meta = columns.List(value_type=columns.Ascii())
+
+    def __init__(self, **kwargs):
+        kwargs["columns_meta"] = [ColumnMetadata(**col) for col in kwargs.pop('columns_meta', [])]
+        super().__init__(**kwargs)
+
+
+class ArgusGenericResultData(Model):
+    __table_name__ = "generic_result_data_v1"
+    test_id = columns.UUID(partition_key=True)
+    name = columns.Text(partition_key=True)
+    run_id = columns.UUID(primary_key=True)
+    column = columns.Ascii(primary_key=True, index=True)
+    row = columns.Ascii(primary_key=True, index=True)
+    sut_timestamp = columns.DateTime()  # for sorting
+    value = columns.Double()
+    status = columns.Ascii()

argus/backend/models/web.py

@@ -6,6 +6,8 @@ from cassandra.cqlengine.usertype import UserType
 from cassandra.cqlengine import columns
 from cassandra.util import uuid_from_time, unix_time_from_uuid1  # pylint: disable=no-name-in-module
 
+from argus.backend.models.result import ArgusGenericResultMetadata, ArgusGenericResultData
+
 
 def uuid_now():
     return uuid_from_time(datetime.utcnow())
@@ -377,6 +379,8 @@ USED_MODELS: list[Model] = [
     ArgusScheduleAssignee,
     ArgusScheduleGroup,
     ArgusScheduleTest,
+    ArgusGenericResultMetadata,
+    ArgusGenericResultData,
 ]
 
 USED_TYPES: list[UserType] = [

argus/backend/plugins/core.py

@@ -30,7 +30,7 @@ class PluginModelBase(Model):
     _plugin_name = "unknown"
     # Metadata
     build_id = columns.Text(required=True, partition_key=True)
-    start_time = columns.DateTime(required=True, primary_key=True, clustering_order="DESC", default=datetime.utcnow, custom_index=True)
+    start_time = columns.DateTime(required=True, primary_key=True, clustering_order="DESC", default=datetime.now, custom_index=True)
     id = columns.UUID(index=True, required=True)
     release_id = columns.UUID(index=True)
     group_id = columns.UUID(index=True)
@@ -105,7 +105,7 @@ class PluginModelBase(Model):
             assignees = ArgusScheduleAssignee.filter(
                 schedule_id=schedule.id
             ).all()
-            assignees_uuids.append(*[assignee.assignee for assignee in assignees])
+            assignees_uuids.extend([assignee.assignee for assignee in assignees])
 
         return assignees_uuids[0] if len(assignees_uuids) > 0 else None
 
@@ -213,6 +213,8 @@ class PluginModelBase(Model):
     def finish_run(self, payload: dict = None):
         raise NotImplementedError()
 
+    def sut_timestamp(self) -> float:
+        raise NotImplementedError()
 
 class PluginInfoBase:
     # pylint: disable=too-few-public-methods

argus/backend/plugins/driver_matrix_tests/controller.py

@@ -1,10 +1,8 @@
 from flask import Blueprint, request
 
 from argus.backend.error_handlers import handle_api_exception
-from argus.backend.plugins.driver_matrix_tests.raw_types import DriverMatrixSubmitEnvRequest, DriverMatrixSubmitFailureRequest, DriverMatrixSubmitResultRequest
 from argus.backend.service.user import api_login_required
 from argus.backend.plugins.driver_matrix_tests.service import DriverMatrixService
-from argus.backend.util.common import get_payload
 
 bp = Blueprint("driver_matrix_api", __name__, url_prefix="/driver_matrix")
 bp.register_error_handler(Exception, handle_api_exception)
@@ -24,40 +22,3 @@ def driver_matrix_test_report():
         "status": "ok",
         "response": result
     }
-
-@bp.route("/result/submit", methods=["POST"])
-@api_login_required
-def submit_result():
-    payload = get_payload(request)
-    request_data = DriverMatrixSubmitResultRequest(**payload)
-
-    result = DriverMatrixService().submit_driver_result(driver_name=request_data.driver_name, driver_type=request_data.driver_type, run_id=request_data.run_id, raw_xml=request_data.raw_xml)
-    return {
-        "status": "ok",
-        "response": result
-    }
-
-
-@bp.route("/result/fail", methods=["POST"])
-@api_login_required
-def submit_failure():
-    payload = get_payload(request)
-    request_data = DriverMatrixSubmitFailureRequest(**payload)
-
-    result = DriverMatrixService().submit_driver_failure(driver_name=request_data.driver_name, driver_type=request_data.driver_type, run_id=request_data.run_id, failure_reason=request_data.failure_reason)
-    return {
-        "status": "ok",
-        "response": result
-    }
-
-@bp.route("/env/submit", methods=["POST"])
-@api_login_required
-def submit_env():
-    payload = get_payload(request)
-    request_data = DriverMatrixSubmitEnvRequest(**payload)
-
-    result = DriverMatrixService().submit_env_info(run_id=request_data.run_id, raw_env=request_data.raw_env)
-    return {
-        "status": "ok",
-        "response": result
-    }

argus/backend/plugins/driver_matrix_tests/model.py

@@ -1,12 +1,8 @@
 from dataclasses import dataclass
 from datetime import datetime
 from functools import reduce
-import logging
-from pprint import pformat
 import re
-from typing import Literal, TypedDict
 from uuid import UUID
-from xml.etree import ElementTree
 from cassandra.cqlengine import columns
 from argus.backend.db import ScyllaCluster
 from argus.backend.models.web import ArgusRelease
@@ -16,8 +12,6 @@ from argus.backend.plugins.driver_matrix_tests.raw_types import RawMatrixTestRes
 from argus.backend.util.enums import TestStatus
 
 
-LOGGER = logging.getLogger(__name__)
-
 class DriverMatrixPluginError(Exception):
     pass
 
@@ -32,65 +26,6 @@ class DriverMatrixRunSubmissionRequest():
     matrix_results: list[RawMatrixTestResult]
 
 
-@dataclass(init=True, repr=True, frozen=True)
-class DriverMatrixRunSubmissionRequestV2():
-    schema_version: str
-    run_id: str
-    job_name: str
-    job_url: str
-
-
-TestTypeType = Literal['java', 'cpp', 'python', 'gocql']
-
-
-class AdaptedXUnitData(TypedDict):
-    timestamp: str
-
-
-def python_driver_matrix_adapter(xml: ElementTree.ElementTree) -> AdaptedXUnitData:
-    testsuites = list(xml.getroot().iter("testsuite"))
-
-    return {
-        "timestamp": testsuites[0].attrib.get("timestamp"),
-    }
-
-
-def java_driver_matrix_adapter(xml: ElementTree.ElementTree) -> AdaptedXUnitData:
-    testsuites = xml.getroot()
-    ts_now = datetime.utcnow().timestamp()
-    try:
-        time_taken = float(testsuites.attrib.get("time"))
-    except ValueError:
-        time_taken = 0.0
-
-    timestamp = datetime.utcfromtimestamp(ts_now - time_taken).isoformat()
-
-    return {
-        "timestamp": timestamp,
-    }
-
-
-def cpp_driver_matrix_adapter(xml: ElementTree.ElementTree) -> AdaptedXUnitData:
-    testsuites = xml.getroot()
-
-    return {
-        "timestamp": testsuites.attrib.get("timestamp"),
-    }
-
-
-def gocql_driver_matrix_adapter(xml: ElementTree.ElementTree) -> AdaptedXUnitData:
-    testsuites = list(xml.getroot().iter("testsuite"))
-
-    return {
-        "timestamp": testsuites[0].attrib.get("timestamp"),
-    }
-
-
-def generic_adapter(xml: ElementTree.ElementTree) -> AdaptedXUnitData:
-    return {
-        "timestamp": datetime.utcnow().isoformat()
-    }
-
 class DriverTestRun(PluginModelBase):
     _plugin_name = "driver-matrix-tests"
     __table_name__ = "driver_test_run"
@@ -100,14 +35,6 @@ class DriverTestRun(PluginModelBase):
 
     _no_upstream = ["rust"]
 
-    _TEST_ADAPTERS = {
-        "java": java_driver_matrix_adapter,
-        "cpp": cpp_driver_matrix_adapter,
-        "python": python_driver_matrix_adapter,
-        "gocql": gocql_driver_matrix_adapter,
-    }
-
-
     _artifact_fnames = {
         "cpp": r"TEST-(?P<driver_name>[\w]*)-(?P<version>[\d\.-]*)",
         "gocql": r"xunit\.(?P<driver_name>[\w]*)\.(?P<proto>v\d)\.(?P<version>[v\d\.]*)",
@@ -151,173 +78,6 @@ class DriverTestRun(PluginModelBase):
 
     @classmethod
     def submit_run(cls, request_data: dict) -> 'DriverTestRun':
-        if request_data["schema_version"] == "v2":
-            req = DriverMatrixRunSubmissionRequestV2(**request_data)
-        else:
-            return cls.submit_matrix_run(request_data)
-
-        run = cls()
-        run.id = req.run_id
-        run.build_id = req.job_name
-        run.build_job_url = req.job_url
-        run.start_time = datetime.utcnow()
-        run.assign_categories()
-        try:
-            run.assignee = run.get_scheduled_assignee()
-        except Exception:  # pylint: disable=broad-except
-            run.assignee = None
-
-        run.status = TestStatus.CREATED.value
-        run.save()
-        return run
-
-    @classmethod
-    def submit_driver_result(cls, run_id: UUID, driver_name: str, driver_type: TestTypeType, xml_data: str):
-        run: DriverTestRun = cls.get(id=run_id)
-
-        collection = run.parse_result_xml(driver_name, xml_data, driver_type)
-        run.test_collection.append(collection)
-
-        if run.status == TestStatus.CREATED:
-            run.status = TestStatus.RUNNING.value
-
-        run.save()
-        return run
-
-
-    @classmethod
-    def submit_driver_failure(cls, run_id: UUID, driver_name: str, driver_type: TestTypeType, fail_message: str):
-        run: DriverTestRun = cls.get(id=run_id)
-
-        collection = TestCollection()
-        collection.failures = 1
-        collection.failure_message = fail_message
-        collection.name = driver_name
-        driver_info = run.get_driver_info(driver_name, driver_type)
-        collection.driver = driver_info.get("driver_name")
-        collection.tests_total = 1
-        run.test_collection.append(collection)
-
-        if run.status == TestStatus.CREATED:
-            run.status = TestStatus.RUNNING.value
-
-        run.save()
-        return run
-
-    @classmethod
-    def submit_env_info(cls, run_id: UUID, env_data: str):
-        run: DriverTestRun = cls.get(id=run_id)
-        env = run.parse_build_environment(env_data)
-
-        for key, value in env.items():
-            env_info = EnvironmentInfo()
-            env_info.key = key
-            env_info.value = value
-            run.environment_info.append(env_info)
-
-        run.scylla_version = env.get("scylla-version")
-
-        run.save()
-        return run
-
-    def parse_build_environment(self, raw_env: str) -> dict[str, str]:
-        result = {}
-        for line in raw_env.split("\n"):
-            if not line:
-                continue
-            LOGGER.debug("ENV: %s", line)
-            key, val = line.split(": ")
-            result[key] = val.strip()
-
-        return result
-
-    def get_test_cases(self, cases: list[ElementTree.Element]) -> list[TestCase]:
-        result = []
-        for raw_case in cases:
-            children = list(raw_case.findall("./*"))
-            if len(children) > 0:
-                status = children[0].tag
-                message = f"{children[0].attrib.get('message', 'no-message')} ({children[0].attrib.get('type', 'no-type')})"
-            else:
-                status = "passed"
-                message = ""
-
-            case = TestCase()
-            case.name = raw_case.attrib["name"]
-            case.status = status
-            case.time = float(raw_case.attrib.get("time", 0.0))
-            case.classname = raw_case.attrib.get("classname", "")
-            case.message = message
-            result.append(case)
-
-        return result
-
-    def get_driver_info(self, xml_name: str, test_type: TestTypeType) -> dict[str, str]:
-        if test_type == "cpp":
-            filename_re = r"TEST-(?P<driver_name>[\w]*)-(?P<version>[\d\.]*)(\.xml)?"
-        else:
-            filename_re = r"(?P<name>[\w]*)\.(?P<driver_name>[\w]*)\.(?P<proto>v\d)\.(?P<version>[\d\.]*)(\.xml)?"
-
-        match = re.match(filename_re, xml_name)
-
-        return match.groupdict() if match else {}
-
-    def get_passed_count(self, suite_attribs: dict[str, str]) -> int:
-        if (pass_count := suite_attribs.get("passed")):
-            return int(pass_count)
-        total = int(suite_attribs.get("tests", 0))
-        errors = int(suite_attribs.get("errors", 0))
-        skipped = int(suite_attribs.get("skipped", 0))
-        failures = int(suite_attribs.get("failures", 0))
-
-        return total - errors - skipped - failures
-
-    def parse_result_xml(self, name: str, xml_data: str, test_type: TestTypeType) -> TestCollection:
-        xml: ElementTree.ElementTree = ElementTree.ElementTree(ElementTree.fromstring(xml_data))
-        LOGGER.debug("%s", pformat(xml))
-        testsuites = xml.getroot()
-        adapted_data = self._TEST_ADAPTERS.get(test_type, generic_adapter)(xml)
-
-        driver_info = self.get_driver_info(name, test_type)
-        test_collection = TestCollection()
-        test_collection.timestamp = datetime.fromisoformat(adapted_data["timestamp"][0:-1] if adapted_data["timestamp"][-1] == "Z" else adapted_data["timestamp"])
-        test_collection.name = name
-        test_collection.driver = driver_info.get("driver_name")
-        test_collection.tests_total = 0
-        test_collection.failures = 0
-        test_collection.errors = 0
-        test_collection.disabled = 0
-        test_collection.skipped = 0
-        test_collection.passed = 0
-        test_collection.time = 0.0
-        test_collection.suites = []
-
-        for xml_suite in testsuites.iter("testsuite"):
-            suite = TestSuite()
-            suite.name = xml_suite.attrib["name"]
-            suite.tests_total = int(xml_suite.attrib.get("tests", 0))
-            suite.failures = int(xml_suite.attrib.get("failures", 0))
-            suite.disabled = int(0)
-            suite.passed = self.get_passed_count(xml_suite.attrib)
-            suite.skipped = int(xml_suite.attrib.get("skipped", 0))
-            suite.errors = int(xml_suite.attrib.get("errors", 0))
-            suite.time = float(xml_suite.attrib["time"])
-            suite.cases = self.get_test_cases(xml_suite.findall("testcase"))
-
-            test_collection.suites.append(suite)
-            test_collection.tests_total += suite.tests_total
-            test_collection.failures += suite.failures
-            test_collection.errors += suite.errors
-            test_collection.disabled += suite.disabled
-            test_collection.skipped += suite.skipped
-            test_collection.passed += suite.passed
-            test_collection.time += suite.time
-
-        return test_collection
-
-    @classmethod
-    def submit_matrix_run(cls, request_data):
-        # Legacy method
         req = DriverMatrixRunSubmissionRequest(**request_data)
         run = cls()
         run.id = req.run_id  # pylint: disable=invalid-name
@@ -386,11 +146,6 @@ class DriverTestRun(PluginModelBase):
         return []
 
     def _determine_run_status(self):
-        for collection in self.test_collection:
-            # patch failure
-            if collection.failure_message:
-                return TestStatus.FAILED
-
         if len(self.test_collection) < 2:
             return TestStatus.FAILED
 
@@ -398,14 +153,14 @@ class DriverTestRun(PluginModelBase):
         if len(driver_types) <= 1 and not any(driver for driver in self._no_upstream if driver in driver_types):
             return TestStatus.FAILED
 
-        failure_count = reduce(lambda acc, val: acc + (val.failures or 0 + val.errors or 0), self.test_collection, 0)
+        failure_count = reduce(lambda acc, val: acc + (val.failures + val.errors), self.test_collection, 0)
         if failure_count > 0:
             return TestStatus.FAILED
 
         return TestStatus.PASSED
 
     def change_status(self, new_status: TestStatus):
-        self.status = new_status
+        raise DriverMatrixPluginError("This method is obsolete. Status is now determined on submission.")
 
     def get_events(self) -> list:
         return []
@@ -415,7 +170,6 @@ class DriverTestRun(PluginModelBase):
 
     def finish_run(self, payload: dict = None):
         self.end_time = datetime.utcnow()
-        self.status = self._determine_run_status().value
 
     def submit_logs(self, logs: list[dict]):
         pass

argus/backend/plugins/driver_matrix_tests/raw_types.py

@@ -1,6 +1,4 @@
-from dataclasses import dataclass
 from typing import TypedDict
-from uuid import UUID
 
 
 class RawMatrixTestCase(TypedDict):
@@ -35,28 +33,3 @@ class RawMatrixTestResult(TypedDict):
     time: float
     timestamp: str
     suites: list[RawMatrixTestSuite]
-
-
-@dataclass(init=True, frozen=True)
-class DriverMatrixSubmitResultRequest():
-    schema_version: str
-    run_id: UUID
-    driver_type: str
-    driver_name: str
-    raw_xml: str
-
-
-@dataclass(init=True, frozen=True)
-class DriverMatrixSubmitFailureRequest():
-    schema_version: str
-    run_id: UUID
-    driver_type: str
-    driver_name: str
-    failure_reason: str
-
-
-@dataclass(init=True, frozen=True)
-class DriverMatrixSubmitEnvRequest():
-    schema_version: str
-    run_id: UUID
-    raw_env: str

argus/backend/plugins/driver_matrix_tests/service.py

@@ -1,13 +1,8 @@
-import base64
-import logging
-from uuid import UUID
 from argus.backend.db import ScyllaCluster
 from argus.backend.models.web import ArgusRelease, ArgusTest
 from argus.backend.plugins.driver_matrix_tests.model import DriverTestRun
 
 
-LOGGER = logging.getLogger(__name__)
-
 class DriverMatrixService:
     def tested_versions_report(self, build_id: str) -> dict:
         db = ScyllaCluster.get()
@@ -45,16 +40,3 @@ class DriverMatrixService:
             "versions": version_map,
         }
         return response
-
-    def submit_driver_result(self, run_id: UUID | str, driver_name: str, driver_type: str, raw_xml: str) -> bool:
-        xml_data = base64.decodebytes(bytes(raw_xml, encoding="utf-8"))
-        DriverTestRun.submit_driver_result(UUID(run_id), driver_name, driver_type, xml_data)
-        return True
-
-    def submit_driver_failure(self, run_id: UUID | str, driver_name: str, driver_type: str, failure_reason: str) -> bool:
-        DriverTestRun.submit_driver_failure(UUID(run_id), driver_name, driver_type, failure_reason)
-        return True
-
-    def submit_env_info(self, run_id: UUID | str, raw_env: str) -> bool:
-        DriverTestRun.submit_env_info(UUID(run_id), raw_env)
-        return True

argus/backend/plugins/driver_matrix_tests/udt.py

@@ -12,12 +12,12 @@ class TestCase(UserType):
 
 class TestSuite(UserType):
     name = columns.Text()
-    tests_total = columns.Integer(default=lambda: 0)
-    failures = columns.Integer(default=lambda: 0)
-    disabled = columns.Integer(default=lambda: 0)
-    skipped = columns.Integer(default=lambda: 0)
-    passed = columns.Integer(default=lambda: 0)
-    errors = columns.Integer(default=lambda: 0)
+    tests_total = columns.Integer()
+    failures = columns.Integer()
+    disabled = columns.Integer()
+    skipped = columns.Integer()
+    passed = columns.Integer()
+    errors = columns.Integer()
     time = columns.Float()
     cases = columns.List(value_type=columns.UserDefinedType(user_type=TestCase))
 
@@ -25,15 +25,14 @@ class TestSuite(UserType):
 class TestCollection(UserType):
     name = columns.Text()
     driver = columns.Text()
-    tests_total = columns.Integer(default=lambda: 0)
-    failure_message = columns.Text()
-    failures = columns.Integer(default=lambda: 0)
-    disabled = columns.Integer(default=lambda: 0)
-    skipped = columns.Integer(default=lambda: 0)
-    passed = columns.Integer(default=lambda: 0)
-    errors = columns.Integer(default=lambda: 0)
+    tests_total = columns.Integer()
+    failures = columns.Integer()
+    disabled = columns.Integer()
+    skipped = columns.Integer()
+    passed = columns.Integer()
+    errors = columns.Integer()
     timestamp = columns.DateTime()
-    time = columns.Float(default=lambda: 0.0)
+    time = columns.Float()
     suites = columns.List(value_type=columns.UserDefinedType(user_type=TestSuite))
 
 

argus/backend/plugins/sct/testrun.py

@@ -249,6 +249,13 @@ class SCTTestRun(PluginModelBase):
 
         self._collect_event_message(event, event_message)
 
+    def sut_timestamp(self) -> float:
+        """converts scylla-server date to timestamp and adds revision in subseconds precision to diffirentiate
+        scylla versions from the same day. It's not perfect, but we don't know exact version time."""
+        scylla_package = [package for package in self.packages if package.name == "scylla-server"][0]
+        return (datetime.strptime(scylla_package.date, '%Y%m%d').timestamp()
+                + int(scylla_package.revision_id, 16) % 1000000 / 1000000)
+
 
 class SCTJunitReports(Model):
     test_id = columns.UUID(primary_key=True, partition_key=True, required=True)

argus/backend/service/client_service.py

@@ -1,5 +1,6 @@
 from uuid import UUID
 from argus.backend.db import ScyllaCluster
+from argus.backend.models.result import ArgusGenericResultMetadata, ArgusGenericResultData
 from argus.backend.plugins.core import PluginModelBase
 from argus.backend.plugins.loader import AVAILABLE_PLUGINS
 from argus.backend.util.enums import TestStatus
@@ -69,3 +70,20 @@ class ClientService:
         run.save()
 
         return "Finalized"
+
+    def submit_results(self, run_type: str, run_id: str, results: dict) -> str:
+        model = self.get_model(run_type)
+        run = model.load_test_run(UUID(run_id))
+        ArgusGenericResultMetadata(test_id=run.test_id, **results["meta"]).save()
+        if results.get("sut_timestamp", 0) == 0:
+            results["sut_timestamp"] = run.sut_timestamp()  # automatic sut_timestamp
+        table_name = results["meta"]["name"]
+        sut_timestamp = results["sut_timestamp"]
+        for cell in results["results"]:
+            ArgusGenericResultData(test_id=run.test_id,
+                                   run_id=run.id,
+                                   name=table_name,
+                                   sut_timestamp=sut_timestamp,
+                                   **cell
+                                   ).save()
+        return "Submitted"

argus/backend/service/testrun.py

@@ -13,6 +13,7 @@ from flask import g
 from cassandra.query import BatchStatement, ConsistencyLevel
 from cassandra.cqlengine.query import BatchQuery
 from argus.backend.db import ScyllaCluster
+from argus.backend.models.result import ArgusGenericResultMetadata, ArgusGenericResultData
 
 from argus.backend.models.web import (
     ArgusEvent,
@@ -306,6 +307,24 @@ class TestRunService:
         }
         return response
 
+    def fetch_results(self, test_id: UUID, run_id: UUID) -> dict:
+        query_fields = ["column", "row", "value", "status"]
+        tables_meta = ArgusGenericResultMetadata.filter(test_id=test_id)
+        tables = []
+        for table in tables_meta:
+            cells = ArgusGenericResultData.objects.filter(test_id=test_id, run_id=run_id, name=table.name).only(query_fields)
+            if not cells:
+                continue
+            tables.append({'meta': {
+                'name': table.name,
+                'description': table.description,
+                'columns_meta': table.columns_meta,
+                'rows_meta': table.rows_meta
+            },
+                'cells': [{k:v for k,v in cell.items() if k in query_fields} for cell in cells]})
+
+        return tables
+
     def submit_github_issue(self, issue_url: str, test_id: UUID, run_id: UUID):
         user_tokens = UserOauthToken.filter(user_id=g.user.id).all()
         token = None