argus-alm 0.12.8__py3-none-any.whl → 0.12.9__py3-none-any.whl

argus/backend/cli.py

@@ -15,6 +15,9 @@ LOGGER = logging.getLogger(__name__)
 @click.command('sync-models')
 @with_appcontext
 def sync_models_command():
+    sync_models()
+
+def sync_models():
     cluster = ScyllaCluster.get()
     cluster.sync_core_tables()
     LOGGER.info("Synchronizing plugin types...")
@@ -29,7 +32,6 @@ def sync_models_command():
     LOGGER.info("Plugins ready.")
     click.echo("All models synchronized.")
 
-
 @cli_bp.cli.add_command
 @click.command('scan-jenkins')
 @with_appcontext

argus/backend/db.py

@@ -54,7 +54,7 @@ class ScyllaCluster:
         return self.cluster.connect(keyspace=self.config["SCYLLA_KEYSPACE_NAME"])
 
     @classmethod
-    def get(cls, config: Config = None) -> 'ScyllaCluster':
+    def get(cls, config: dict = None) -> 'ScyllaCluster':
         if cls.APP_INSTANCE:
             return cls.APP_INSTANCE
 

argus/backend/models/result.py

@@ -1,22 +1,21 @@
+import math
+from datetime import datetime, timezone
+
 from cassandra.cqlengine import columns
 from cassandra.cqlengine.models import Model
 from cassandra.cqlengine.usertype import UserType
 
-class BestResult(UserType):
-    date = columns.DateTime()
-    value = columns.Double()
-    run_id = columns.UUID()
-
 class ValidationRules(UserType):
-    higher_is_better = columns.Boolean()
-    margin_percent = columns.Double()
-    margin_value = columns.Double()
-    limit = columns.Double()
+    valid_from = columns.DateTime()
+    best_pct = columns.Double()  # max value limit relative to best result in percent unit
+    best_abs = columns.Double()  # max value limit relative to best result in absolute unit
+    fixed_limit = columns.Double()  # fixed limit
 
 class ColumnMetadata(UserType):
     name = columns.Ascii()
     unit = columns.Text()
     type = columns.Ascii()
+    higher_is_better = columns.Boolean()  # used for tracking best results, if None - no tracking
 
 
 class ArgusGenericResultMetadata(Model):
@@ -25,17 +24,68 @@ class ArgusGenericResultMetadata(Model):
     name = columns.Text(required=True, primary_key=True)
     description = columns.Text()
     columns_meta = columns.List(value_type=columns.UserDefinedType(ColumnMetadata))
-    validation_rules = columns.Map(key_type=columns.Ascii(), value_type=columns.List(value_type=columns.UserDefinedType(ValidationRules)))
-    best_results = columns.Map(key_type=columns.Ascii(), value_type=columns.UserDefinedType(BestResult))
+    validation_rules = columns.Map(key_type=columns.Ascii(), value_type=columns.List(columns.UserDefinedType(ValidationRules)))
     rows_meta = columns.List(value_type=columns.Ascii())
 
     def __init__(self, **kwargs):
         kwargs["columns_meta"] = [ColumnMetadata(**col) for col in kwargs.pop('columns_meta', [])]
-        kwargs["best_results"] = {k: [BestResult(**z) for z in v] for k, v in kwargs.pop('best_results', {}).items()}
-        kwargs["validation_rules"] = {k: ValidationRules(**v) for k, v in kwargs.pop('validation_rules', {}).items()}
+        validation_rules = kwargs.pop('validation_rules', {})
+
+        if validation_rules:
+            for column, rule in validation_rules.items():
+                if not isinstance(rule, list):
+                    rule['valid_from'] = datetime.now(timezone.utc)
+                    validation_rules[column] = [rule]
+            kwargs["validation_rules"] = {k: [ValidationRules(**rules) for rules in v] for k, v in validation_rules.items()}
         super().__init__(**kwargs)
 
-    def update_if_changed(self, new_data: dict) -> None:
+    def update_validation_rules(self, key: str, new_rule_dict: dict) -> bool:
+        """
+        Checks if the most recent ValidationRule for the given key matches the new_rule_dict.
+        If not, adds the new rule to the list with the current timestamp.
+
+        :param key: The key (column name) in the validation_rules map to update.
+        :param new_rule_dict: A dictionary containing the new validation rule values.
+        :return: True if a new rule was added, False if the existing rule matches.
+        """
+        rules_list = self.validation_rules.get(key, [])
+        most_recent_rule = None
+
+        if rules_list:
+            most_recent_rule = rules_list[-1]
+
+        fields_to_compare = [field for field in ValidationRules._fields if field != 'valid_from']
+        rules_match = True
+        if most_recent_rule:
+            for field in fields_to_compare:
+                db_value = getattr(most_recent_rule, field)
+                new_value = new_rule_dict.get(field)
+                if db_value is None and new_value is None:
+                    continue
+                if db_value is None or new_value is None:
+                    rules_match = False
+                    break
+                if not math.isclose(db_value, new_value, rel_tol=1e-9, abs_tol=0.0):
+                    rules_match = False
+                    break
+        else:
+            rules_match = False
+
+        if not rules_match:
+            new_rule = ValidationRules(
+                valid_from=datetime.now(timezone.utc),
+                best_pct=new_rule_dict.get('best_pct'),
+                best_abs=new_rule_dict.get('best_abs'),
+                fixed_limit=new_rule_dict.get('fixed_limit')
+            )
+            rules_list.append(new_rule)
+            self.validation_rules = self.validation_rules or {}
+            self.validation_rules.update({key: rules_list})
+            return True
+
+        return False  # Existing rule matches
+
+    def update_if_changed(self, new_data: dict) -> "ArgusGenericResultMetadata":
         """
         Updates table metadata if changed column/description or new rows were added.
         See that rows can only be added, not removed once was sent.
@@ -45,22 +95,26 @@ class ArgusGenericResultMetadata(Model):
         for field, value in new_data.items():
             if field == "columns_meta":
                 value = [ColumnMetadata(**col) for col in value]
+                if self.columns_meta != value:
+                    self.columns_meta = value
+                    updated = True
             elif field == "rows_meta":
                 added_rows = []
                 for row in value:
                     if row not in self.rows_meta:
                         added_rows.append(row)
-                value = self.rows_meta + added_rows
-            elif field == "best_results":
-                value = {k: [BestResult(**z) for z in v] for k, v in value.items()}
+                        updated = True
+                self.rows_meta += added_rows
             elif field == "validation_rules":
-                value = {k: ValidationRules(**v) for k, v in value.items()}
-            if getattr(self, field) != value:
+                if any([self.update_validation_rules(key, rules) for key, rules in value.items()]):
+                    updated = True
+            elif getattr(self, field) != value:
                 setattr(self, field, value)
                 updated = True
 
         if updated:
             self.save()
+        return self
 
 class ArgusGenericResultData(Model):
     __table_name__ = "generic_result_data_v1"
@@ -73,3 +127,12 @@ class ArgusGenericResultData(Model):
     value = columns.Double()
     value_text = columns.Text()
     status = columns.Ascii()
+
+class ArgusBestResultData(Model):
+    __table_name__ = "generic_result_best_v1"
+    test_id = columns.UUID(partition_key=True)
+    name = columns.Text(partition_key=True)
+    key = columns.Ascii(primary_key=True)  # represents pair column:row
+    result_date = columns.DateTime(primary_key=True, clustering_order="DESC")
+    value = columns.Double()
+    run_id = columns.UUID()

argus/backend/models/web.py

@@ -6,7 +6,7 @@ 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
+from argus.backend.models.result import ArgusGenericResultMetadata, ArgusGenericResultData, ArgusBestResultData
 
 
 def uuid_now():
@@ -381,6 +381,7 @@ USED_MODELS: list[Model] = [
     ArgusScheduleTest,
     ArgusGenericResultMetadata,
     ArgusGenericResultData,
+    ArgusBestResultData,
 ]
 
 USED_TYPES: list[UserType] = [

argus/backend/plugins/loader.py

@@ -30,7 +30,7 @@ def plugin_loader() -> dict[str, PluginInfoBase]:
 
 
 AVAILABLE_PLUGINS = plugin_loader()
-
+print(AVAILABLE_PLUGINS)
 
 def all_plugin_models(include_all=False) -> list[PluginModelBase]:
     return [model for plugin in AVAILABLE_PLUGINS.values() for model in plugin.all_models if issubclass(model, PluginModelBase) or include_all]

argus/backend/plugins/sct/testrun.py

@@ -258,7 +258,10 @@ class SCTTestRun(PluginModelBase):
             scylla_package_upgraded = [package for package in self.packages if package.name == "scylla-server-upgraded"][0]
         except IndexError:
             scylla_package_upgraded = None
-        scylla_package = scylla_package_upgraded or [package for package in self.packages if package.name == "scylla-server"][0]
+        try:
+            scylla_package = [package for package in self.packages if package.name == "scylla-server"][0]
+        except IndexError:
+            raise ValueError("Scylla package not found in packages - cannot determine SUT timestamp")
         return (datetime.strptime(scylla_package.date, '%Y%m%d').replace(tzinfo=timezone.utc).timestamp()
                 + int(scylla_package.revision_id, 16) % 1000000 / 1000000)
 

argus/backend/service/client_service.py

@@ -1,8 +1,14 @@
+import operator
+from dataclasses import asdict, is_dataclass
+from datetime import datetime, timezone
+from functools import partial
 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.service.results_service import ResultsService, Cell
 from argus.backend.util.enums import TestStatus
 
 
@@ -25,8 +31,9 @@ class ClientService:
     def submit_run(self, run_type: str, request_data: dict) -> str:
         model = self.get_model(run_type)
         model.submit_run(request_data=request_data)
+
         return "Created"
-    
+
     def get_run(self, run_type: str, run_id: str):
         model = self.get_model(run_type)
         try:
@@ -85,23 +92,31 @@ class ClientService:
             run = model.load_test_run(UUID(run_id))
         except model.DoesNotExist:
             return {"status": "error", "response": {
-            "exception": "DoesNotExist",
-            "arguments": [run_id]
-        }}
-        existing_table = ArgusGenericResultMetadata.objects(test_id=run.test_id, name=results["meta"]["name"]).first()
-        if existing_table:
-            existing_table.update_if_changed(results["meta"])
+                "exception": "DoesNotExist",
+                "arguments": [run_id]
+            }}
+        table_name = results["meta"]["name"]
+        results_service = ResultsService()
+        cells = [Cell(**cell) for cell in results["results"]]
+        table_metadata = results_service.get_table_metadata(test_id=run.test_id, table_name=table_name)
+        if table_metadata:
+            table_metadata = table_metadata.update_if_changed(results["meta"])
         else:
-            ArgusGenericResultMetadata(test_id=run.test_id, **results["meta"]).save()
+            table_metadata = ArgusGenericResultMetadata(test_id=run.test_id, **results["meta"])
+            table_metadata.save()
         if results.get("sut_timestamp", 0) == 0:
             results["sut_timestamp"] = run.sut_timestamp()  # automatic sut_timestamp
+        results["sut_timestamp"] = datetime.fromtimestamp(results["sut_timestamp"])
+        best_results = results_service.update_best_results(test_id=run.test_id, table_name=table_name, table_metadata=table_metadata,
+                                                           cells=cells, run_id=run_id)
         table_name = results["meta"]["name"]
         sut_timestamp = results["sut_timestamp"]
-        for cell in results["results"]:
+        for cell in cells:
+            cell.update_cell_status_based_on_rules(table_metadata, best_results)
             ArgusGenericResultData(test_id=run.test_id,
                                    run_id=run.id,
                                    name=table_name,
                                    sut_timestamp=sut_timestamp,
-                                   **cell
+                                   **asdict(cell)
                                    ).save()
         return {"status": "ok", "message": "Results submitted"}

argus/backend/service/notification_manager.py

@@ -93,7 +93,8 @@ class NotificationSenderBase:
 
 class ArgusDBNotificationSaver(NotificationSenderBase):
     CONTENT_TEMPLATES = {
-        ArgusNotificationTypes.Mention: lambda p: render_template("notifications/mention.html.j2", **p if p else {})
+        ArgusNotificationTypes.Mention: lambda p: render_template("notifications/mention.html.j2", **p if p else {}),
+        ArgusNotificationTypes.AssigneeChange: lambda p: render_template("notifications/assigned.html.j2", **p if p else {}),
     }
 
     def send_notification(self, receiver: UUID, sender: UUID, notification_type: ArgusNotificationTypes, source_type: ArgusNotificationSourceTypes,
@@ -117,7 +118,8 @@ class ArgusDBNotificationSaver(NotificationSenderBase):
 class EmailNotificationServiceSender(NotificationSenderBase):
     CONTENT_TEMPLATES = {
         ArgusNotificationTypes.Mention: lambda p: render_template(
-            "notifications/email_mention.html.j2", **p if p else {})
+            "notifications/email_mention.html.j2", **p if p else {}),
+        ArgusNotificationTypes.AssigneeChange: lambda p: render_template("notifications/assigned_email.html.j2", **p if p else {}),
     }
 
     def __init__(self):

argus/backend/service/results_service.py

@@ -1,14 +1,61 @@
 import copy
 import logging
 import math
+import operator
+from datetime import datetime, timezone
+from functools import partial
 from typing import List, Dict, Any
 from uuid import UUID
 
+from dataclasses import dataclass
 from argus.backend.db import ScyllaCluster
-from argus.backend.models.result import ArgusGenericResultMetadata, ArgusGenericResultData
+from argus.backend.models.result import ArgusGenericResultMetadata, ArgusGenericResultData, ArgusBestResultData
 
 LOGGER = logging.getLogger(__name__)
 
+
+@dataclass
+class BestResult:
+    key: str
+    value: float
+    result_date: datetime
+    run_id: str
+
+
+@dataclass
+class Cell:
+    column: str
+    row: str
+    status: str
+    value: Any | None = None
+    value_text: str | None = None
+
+    def update_cell_status_based_on_rules(self, table_metadata: ArgusGenericResultMetadata, best_results: dict[str, BestResult],
+                                          ) -> None:
+        column_validation_rules = table_metadata.validation_rules.get(self.column)
+        rules = column_validation_rules[-1] if column_validation_rules else {}
+        higher_is_better = next((col.higher_is_better for col in table_metadata.columns_meta if col.name == self.column), None)
+        if not rules or self.status != "UNSET" or higher_is_better is None:
+            return
+        is_better = partial(operator.gt, self.value) if higher_is_better else partial(operator.lt, self.value)
+        key = f"{self.column}:{self.row}"
+        limits = []
+        if rules.fixed_limit is not None:
+            limits.append(rules.fixed_limit)
+
+        if best_result := best_results.get(key):
+            best_value = best_result.value
+            if (best_pct := rules.best_pct) is not None:
+                multiplier = 1 - best_pct / 100 if higher_is_better else 1 + best_pct / 100
+                limits.append(best_value * multiplier)
+            if (best_abs := rules.best_abs) is not None:
+                limits.append(best_value - best_abs if higher_is_better else best_value + best_abs)
+        if all(is_better(limit) for limit in limits):
+            self.status = "PASS"
+        else:
+            self.status = "ERROR"
+
+
 default_options = {
     "scales": {
         "y": {
@@ -146,10 +193,10 @@ def calculate_graph_ticks(graphs: List[Dict]) -> dict[str, str]:
 
 
 class ResultsService:
-    
+
     def __init__(self):
         self.cluster = ScyllaCluster.get()
-    
+
     def _get_tables_metadata(self, test_id: UUID) -> list[ArgusGenericResultMetadata]:
         query_fields = ["name", "description", "columns_meta", "rows_meta"]
         raw_query = (f"SELECT {','.join(query_fields)}"
@@ -158,6 +205,12 @@ class ResultsService:
         tables_meta = self.cluster.session.execute(query=query, parameters=(test_id,))
         return [ArgusGenericResultMetadata(**table) for table in tables_meta]
 
+    def get_table_metadata(self, test_id: UUID, table_name: str) -> ArgusGenericResultMetadata:
+        raw_query = ("SELECT * FROM generic_result_metadata_v1 WHERE test_id = ? AND name = ?")
+        query = self.cluster.prepare(raw_query)
+        table_meta = self.cluster.session.execute(query=query, parameters=(test_id, table_name))
+        return [ArgusGenericResultMetadata(**table) for table in table_meta][0] if table_meta else None
+
     def get_run_results(self, test_id: UUID, run_id: UUID) -> list[dict]:
         query_fields = ["column", "row", "value", "value_text", "status"]
         raw_query = (f"SELECT {','.join(query_fields)},WRITETIME(status) as ordering"
@@ -199,3 +252,66 @@ class ResultsService:
     def is_results_exist(self, test_id: UUID):
         """Verify if results for given test id exist at all."""
         return bool(ArgusGenericResultMetadata.objects(test_id=test_id).only(["name"]).limit(1))
+
+    def get_best_results(self, test_id: UUID, name: str) -> List[BestResult]:
+        query_fields = ["key", "value", "result_date", "run_id"]
+        raw_query = (f"SELECT {','.join(query_fields)}"
+                     f" FROM generic_result_best_v1 WHERE test_id = ? and name = ?")
+        query = self.cluster.prepare(raw_query)
+        best_results = self.cluster.session.execute(query=query, parameters=(test_id, name))
+        return [BestResult(**best) for best in best_results]
+
+    @staticmethod
+    def _update_best_value(best_results: dict[str, list[dict]], higher_is_better_map: dict[str, bool | None], cells: list[dict],
+                           sut_timestamp: float, run_id: str
+                           ) -> dict[str, list[dict]]:
+
+        for cell in cells:
+            if "column" not in cell or "row" not in cell or "value" not in cell:
+                continue
+            column, row, value = cell["column"], cell["row"], cell["value"]
+            key_name = f"{column}_{row}"
+            if higher_is_better_map[column] is None:
+                # skipping updating best value when higher_is_better is not set (not enabled by user)
+                return best_results
+            if key_name not in best_results:
+                best_results[key_name] = []
+                current_best = None
+            else:
+                current_best = best_results[key_name][-1]
+                if current_best["sut_timestamp"].timestamp() > sut_timestamp:
+                    # skip updating best value when testing older version than current best
+                    # as would have to update all values between these dates to make cells statuses to be consistent
+                    return best_results
+
+            is_better = partial(operator.gt, value) if higher_is_better_map[column] else partial(operator.lt, value)
+            if current_best is None or is_better(current_best["value"]):
+                best_results[key_name].append({"sut_timestamp": sut_timestamp, "value": value, "run_id": run_id})
+        return best_results
+
+    def update_best_results(self, test_id: UUID, table_name: str, cells: list[Cell],
+                            table_metadata: ArgusGenericResultMetadata, run_id: str) -> dict[str, BestResult]:
+        """update best results for given test_id and table_name based on cells values - if any value is better than current best"""
+        higher_is_better_map = {meta["name"]: meta.higher_is_better for meta in table_metadata.columns_meta}
+        best_results = {}
+        for best in self.get_best_results(test_id=test_id, name=table_name):
+            if best.key not in best_results:
+                best_results[best.key] = best
+
+        for cell in cells:
+            if cell.value is None:
+                # textual value, skip
+                continue
+            key = f"{cell.column}:{cell.row}"
+            if higher_is_better_map[cell.column] is None:
+                # skipping updating best value when higher_is_better is not set (not enabled by user)
+                continue
+            current_best = best_results.get(key)
+            is_better = partial(operator.gt, cell.value) if higher_is_better_map[cell.column] \
+                else partial(operator.lt, cell.value)
+            if current_best is None or is_better(current_best.value):
+                result_date = datetime.now(timezone.utc)
+                best_results[key] = BestResult(key=key, value=cell.value, result_date=result_date, run_id=run_id)
+                ArgusBestResultData(test_id=test_id, name=table_name, key=key, value=cell.value, result_date=result_date,
+                                    run_id=run_id).save()
+        return best_results

argus/backend/service/testrun.py

@@ -203,6 +203,22 @@ class TestRunService:
             group_id=test.group_id,
             test_id=test.id
         )
+        if new_assignee_user.id != g.user.id:
+            self.notification_manager.send_notification(
+                receiver=new_assignee_user.id,
+                sender=g.user.id,
+                notification_type=ArgusNotificationTypes.AssigneeChange,
+                source_type=ArgusNotificationSourceTypes.TestRun,
+                source_id=run.id,
+                source_message=str(run.test_id),
+                content_params={
+                    "username": g.user.username,
+                    "run_id": run.id,
+                    "test_id": test.id,
+                    "build_id": run.build_id,
+                    "build_number": get_build_number(run.build_job_url),
+                }
+            )
         return {
             "test_run_id": run.id,
             "assignee": str(new_assignee_user.id) if new_assignee_user else None

argus/backend/tests/argus_web.test.yaml

@@ -0,0 +1,39 @@
+# BASE URL FOR ARGUS APPLICATION
+BASE_URL: "https://argus.scylladb.com"
+# Main DB Cluster contact points
+SCYLLA_CONTACT_POINTS:
+  - 172.18.0.2
+# Username
+SCYLLA_USERNAME: cassandra
+# Password
+SCYLLA_PASSWORD: cassandra
+# Default keyspace (can be created using 'create-keyspace' command with RF set to the number of contact points)
+SCYLLA_KEYSPACE_NAME: test_argus
+# Replication factor used - if set, will override contact_points as amount of nodes for replication
+# SCYLLA_REPLICATION_FACTOR: 3
+LOGIN_METHODS:
+  - gh
+# Application log level
+APP_LOG_LEVEL: INFO
+# Secret key used to match session data
+SECRET_KEY: MUSTBEUNIQUE1
+# Client ID of a github oauth application
+GITHUB_CLIENT_ID: not_set
+# Scopes used for Github Application:
+# GITHUB_SCOPES: 'user:email read:user read:org repo'
+# Client secret of a github oauth application
+GITHUB_CLIENT_SECRET: not_set
+# Github personal access token
+GITHUB_ACCESS_TOKEN: unknown
+# List of required organization names (Comment out to disable organization requirement)
+GITHUB_REQUIRED_ORGANIZATIONS:
+  # at least one is required for user to successfully authenticate
+BUILD_SYSTEM_FILTERED_PREFIXES:
+  - prefixToExclude
+JENKINS_URL: https://jenkins.scylladb.com
+JENKINS_USER: not_set
+JENKINS_API_TOKEN_NAME: not_set
+JENKINS_API_TOKEN: not_set
+JENKINS_MONITORED_RELEASES:
+  - not_set
+

argus/backend/tests/conftest.py

@@ -0,0 +1,44 @@
+import os
+from pathlib import Path
+from unittest.mock import patch
+
+from _pytest.fixtures import fixture
+
+from argus.backend.cli import sync_models
+from argus.backend.db import ScyllaCluster
+from argus.backend.service.client_service import ClientService
+from argus.backend.service.release_manager import ReleaseManagerService
+from argus.backend.util.config import Config
+import logging
+os.environ['CQLENG_ALLOW_SCHEMA_MANAGEMENT'] = '1'
+logging.getLogger('cassandra').setLevel(logging.WARNING)
+logging.getLogger('cassandra.connection').setLevel(logging.WARNING)
+logging.getLogger('cassandra.pool').setLevel(logging.WARNING)
+logging.getLogger('cassandra.cluster').setLevel(logging.WARNING)
+
+def truncate_all_tables(session):
+    for table in session.cluster.metadata.keyspaces[session.keyspace].tables:
+        session.execute(f"TRUNCATE {table}")
+
+
+@fixture(autouse=True, scope='session')
+def argus_db():
+    Config.CONFIG_PATHS = [Path(__file__).parent / "argus_web.test.yaml"]
+    config = Config.load_yaml_config()
+    database = ScyllaCluster.get(config)
+    session = database.cluster.connect(keyspace=config["SCYLLA_KEYSPACE_NAME"])
+    ScyllaCluster.get_session = lambda: session  # monkey patching to escape need for flask app context
+
+    sync_models()
+    truncate_all_tables(database.session)
+    yield database
+    database.shutdown()
+
+
+@fixture(autouse=True, scope='session')
+def release_manager_service(argus_db):
+    return ReleaseManagerService()
+
+@fixture(autouse=True, scope='session')
+def client_service(argus_db):
+    return ClientService()

argus/backend/tests/results_service/test_best_results.py

@@ -0,0 +1,70 @@
+import logging
+import uuid
+from dataclasses import asdict
+from typing import Optional, Dict
+
+from _pytest.fixtures import fixture
+
+from argus.backend.plugins.sct.testrun import SCTTestRunSubmissionRequest
+from argus.client.generic_result import GenericResultTable, ColumnMetadata, ResultType, ValidationRule
+
+LOGGER = logging.getLogger(__name__)
+
+@fixture(autouse=True, scope='session')
+def release(release_manager_service):
+    return release_manager_service.create_release("best_results", "best_results", False)
+
+
+@fixture(autouse=True, scope='session')
+def group(release_manager_service, release):
+    return release_manager_service.create_group("br_group", "best_results", build_system_id="best_results", release_id=str(release.id))
+
+def get_fake_test_run(
+    schema_version: str = "1.0.0",
+    run_id: str = str(uuid.uuid4()),
+    job_name: str = "default_job_name",
+    job_url: str = "http://example.com",
+    started_by: str = "default_user",
+    commit_id: str = "default_commit_id",
+    sct_config: dict | None = None,
+    origin_url: str | None = None,
+    branch_name: str | None = "main",
+    runner_public_ip: str | None = None,
+    runner_private_ip: str | None = None
+) -> tuple[str, dict]:
+    return "scylla-cluster-tests", asdict(SCTTestRunSubmissionRequest(
+        schema_version=schema_version,
+        run_id=run_id,
+        job_name=job_name,
+        job_url=job_url,
+        started_by=started_by,
+        commit_id=commit_id,
+        sct_config=sct_config,
+        origin_url=origin_url,
+        branch_name=branch_name,
+        runner_public_ip=runner_public_ip,
+        runner_private_ip=runner_private_ip
+    ))
+
+class SampleTable(GenericResultTable):
+    class Meta:
+        name = "Test Table Name"
+        description = "Test Table Description"
+        Columns = [ColumnMetadata(name="float col name", unit="ms", type=ResultType.FLOAT, higher_is_better=False),
+                   ColumnMetadata(name="int col name", unit="ms", type=ResultType.INTEGER, higher_is_better=False),
+                   ColumnMetadata(name="duration col name", unit="s", type=ResultType.DURATION, higher_is_better=False),
+                   ColumnMetadata(name="non tracked col name", unit="", type=ResultType.FLOAT),
+                   ColumnMetadata(name="text col name", unit="", type=ResultType.TEXT),
+                   ]
+        ValidationRules = {"float col name": ValidationRule(best_abs=4),
+                           "int col name": ValidationRule(best_pct=50, best_abs=5),
+                           "duration col name": ValidationRule(fixed_limit=590)
+                           }
+
+def test_argus_tracks_best_result(release_manager_service, client_service, release, group):
+    test = release_manager_service.create_test('track_best_result', 'track_best_result', 'track_best_result', 'track_best_result',
+                                               group_id=str(group.id), release_id=str(release.id), plugin_name='sct')
+    print(test)
+    LOGGER.warning(f"available plugins: {client_service.PLUGINS}")
+    client_service.submit_run(*get_fake_test_run())
+    assert test

argus/client/generic_result.py

@@ -28,15 +28,30 @@ class ColumnMetadata:
     name: str
     unit: str
     type: ResultType
+    higher_is_better: bool = None
 
     def as_dict(self) -> dict:
         return {
             "name": self.name,
             "unit": self.unit,
-            "type": str(self.type)
+            "type": str(self.type),
+            "higher_is_better": self.higher_is_better
         }
 
 
+@dataclass
+class ValidationRule:
+    best_pct: float | None = None  # max value limit relative to best result in percent unit
+    best_abs: float | None = None  # max value limit relative to best result in absolute unit
+    fixed_limit: float | None = None
+
+    def as_dict(self) -> dict:
+        return {
+            "best_pct": self.best_pct,
+            "best_abs": self.best_abs,
+            "fixed_limit": self.fixed_limit
+        }
+
 class ResultTableMeta(type):
     def __new__(cls, name, bases, dct):
         cls_instance = super().__new__(cls, name, bases, dct)
@@ -48,6 +63,14 @@ class ResultTableMeta(type):
             cls_instance.columns = meta.Columns
             cls_instance.column_types = {column.name: column.type for column in cls_instance.columns}
             cls_instance.rows = []
+            for col_name, rule in meta.ValidationRules.items():
+                if col_name not in cls_instance.column_types:
+                    raise ValueError(f"ValidationRule column {col_name} not found in the table")
+                if cls_instance.column_types[col_name] == ResultType.TEXT:
+                    raise ValueError(f"Validation rules don't apply to TEXT columns")
+                if not isinstance(rule, ValidationRule):
+                    raise ValueError(f"Validation rule for column {col_name} is not of type ValidationRule")
+            cls_instance.validation_rules = meta.ValidationRules
         return cls_instance
 
 
@@ -87,7 +110,8 @@ class GenericResultTable(metaclass=ResultTableMeta):
             "name": self.name,
             "description": self.description,
             "columns_meta": [column.as_dict() for column in self.columns],
-            "rows_meta": rows
+            "rows_meta": rows,
+            "validation_rules": {k: v.as_dict() for k, v in self.validation_rules.items()}
         }
         return {
             "meta": meta_info,

{argus_alm-0.12.8.dist-info → argus_alm-0.12.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: argus-alm
-Version: 0.12.8
+Version: 0.12.9
 Summary: Argus
 Home-page: https://github.com/scylladb/argus
 License: Apache-2.0

{argus_alm-0.12.8.dist-info → argus_alm-0.12.9.dist-info}/RECORD

@@ -1,7 +1,7 @@
 argus/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 argus/backend/.gitkeep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 argus/backend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-argus/backend/cli.py,sha256=fWSS1m0mhQeCwfH58Qfs4Cicxc95IKi9vwmQn3SUYs0,1346
+argus/backend/cli.py,sha256=ULa9KVv7RR3DVHKlYvsSdIfbX5s-VuiPuhWWRfPkdGU,1383
 argus/backend/controller/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 argus/backend/controller/admin.py,sha256=2z29RX7ZQO_VTklSKH9RrEj-Ag2SsvyOaIzWDKr0ahQ,575
 argus/backend/controller/admin_api.py,sha256=lj5g6rdoKN9X13H9hXmKYx_-9tftt6HSftiNFLCr_kY,8567
@@ -15,12 +15,12 @@ argus/backend/controller/team.py,sha256=G6LdIBaYgfG0Qr4RhNQ53MZVdh4wcuotsIIpFwhT
 argus/backend/controller/team_ui.py,sha256=B7N1_Kzl6Rac8BV3FbKj55pGAS_dht47rYhAi94PC8A,589
 argus/backend/controller/testrun_api.py,sha256=MCcVmbfNuyODCVbxF8TfcvVu9sMT0xO1UzS4VgumQiM,12638
 argus/backend/controller/view_api.py,sha256=rI7LwcS7keK37nYx76D9StFV_rLHcNkHan8OhFgBrhM,4106
-argus/backend/db.py,sha256=bBiraYD05Qex28yZHjSP1bRlcMsc6oTYGt792zXmaHo,4101
+argus/backend/db.py,sha256=IgeGjZKTHSoyGrd5f2A7uYn6Pm6DU2-ZIESHmfJwkoE,4099
 argus/backend/error_handlers.py,sha256=IEjz7Vzfldv1PTOeHrpRWmRsgBrHtAW0PXHUJZDovAE,480
 argus/backend/events/event_processors.py,sha256=bsmBayiXvlGn3aqiT2z9WgwnVBRtn2cRqkgn4pLodck,1291
 argus/backend/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-argus/backend/models/result.py,sha256=H2VOIWiQgkSHtFVK7piwlsEFML4qLOjhhuIFSXVJPjs,3182
-argus/backend/models/web.py,sha256=4K1Gj70nugmuW3sv0Sv5M_sVSmEhfJgxRE670qChGzo,13095
+argus/backend/models/result.py,sha256=DOgxHwerJIyMsqsbDdMYSojkUPiWsu6mHCq9B8JpaBA,5899
+argus/backend/models/web.py,sha256=eJybumxShBrFIdi0H0zHcEuAusfpZKpDrZ4Bxl_JyUY,13141
 argus/backend/plugins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 argus/backend/plugins/core.py,sha256=UsrK8oWyhpDSLEcnqAQsEqYVUIX0eCQB862Em7GMQLo,8690
 argus/backend/plugins/driver_matrix_tests/controller.py,sha256=GdPpProzsVXQw8A4h2IS8inUPdr_Q4IN93i6ocOThS8,2213
@@ -32,12 +32,12 @@ argus/backend/plugins/driver_matrix_tests/udt.py,sha256=WRtnJU1dZcLXZJQgfU0mgjNz
 argus/backend/plugins/generic/model.py,sha256=QLVO7QhGr38Hz0VO-BlDYF7LhRX7Pl049vw4W_VMT8o,3302
 argus/backend/plugins/generic/plugin.py,sha256=5URbQVUCizrk-KZqb6I0P_8nLUekjYh-Js7ZLKVoBAA,407
 argus/backend/plugins/generic/types.py,sha256=jlZUcQ7r153ziyl3ZJmix7AzL2G1aX9N_z-4Kw9trWc,267
-argus/backend/plugins/loader.py,sha256=6PUrMjXKoCSDazMRkUHt8qxpniRhuqhY8Tof8lzeunk,1390
+argus/backend/plugins/loader.py,sha256=L3OUNt0e2RrxGD5dIl0PonEAKZj0f9gXcpk7_ifjVuc,1414
 argus/backend/plugins/sct/controller.py,sha256=NF11JLoUJ13whghlxRrVex9rLMgFtlkczUAAKAM9vYg,5738
 argus/backend/plugins/sct/plugin.py,sha256=_sOMcXLoFfeG9jwj_t48C4IFvY87juK8ApR6tfSw6q4,1007
 argus/backend/plugins/sct/resource_setup.py,sha256=hwfAOu-oKOH42tjtzJhiqwq_MtUE9_HevoFyql8JKqY,10120
 argus/backend/plugins/sct/service.py,sha256=ygAL85BkyyovJ1xHktlCQJdJS8CrerJZ_Tbr3EXqsg4,22021
-argus/backend/plugins/sct/testrun.py,sha256=XV7aCK88nSw-SN5R_8rGpoOoQBDUUUm6YwmJQfI8P8k,10537
+argus/backend/plugins/sct/testrun.py,sha256=O7LanXF-fHiHfUAqsr7ALhTmcpVfjAYQODQTdB-u3Ig,10656
 argus/backend/plugins/sct/types.py,sha256=Gw1y4iqYguqNqTh_GopLDFho8vuGaOGuK7fjaHYhAOQ,1326
 argus/backend/plugins/sct/udt.py,sha256=V_x8_yw8rV7Q_QRBYayqtTNsPdZvjzOxWpRhXP1XAzs,3119
 argus/backend/plugins/sirenada/model.py,sha256=KVnI75BacuBryc5lR_Aai-mEOs7CB9xxhb7J-YRU3bc,4705
@@ -46,18 +46,23 @@ argus/backend/plugins/sirenada/types.py,sha256=Gm3XMK9YJoozVaeM9XE7n8iRxA6PKBrS2
 argus/backend/service/admin.py,sha256=_VnWl3CkZBOAie_pPbd9sbXZUpBf2SApyNoFZLfB_QI,637
 argus/backend/service/argus_service.py,sha256=YF6El9CyIelePDrCydVn4K82sd7CzCoZNmcvn2ZeR9I,29266
 argus/backend/service/build_system_monitor.py,sha256=QB7RfMMuA2VJ4oUAOAqLxOwxqaQE52_4ZhsASVcoXkU,8296
-argus/backend/service/client_service.py,sha256=4u4kAl5aeeScQhhUQdkXqwjje-YWrjTLpzSljKVXDAQ,3965
+argus/backend/service/client_service.py,sha256=XAAZ8VOVg2ppwcWVh8asGvYdlMuqFWjkcF-z-DCKD9c,4754
 argus/backend/service/event_service.py,sha256=iYeqxN2QCYTjYB1WPPv4BEFLXG0Oz3TvskkaK4v9pVY,654
 argus/backend/service/jenkins_service.py,sha256=njomagkliIWKisR9FmhKKqZ8y9NijyJ3hUQe23gl2U4,9878
-argus/backend/service/notification_manager.py,sha256=h00Ej_-hH9H7pq0wah_1TH8dnpPyPNsgVJNO1rwJi7o,7011
+argus/backend/service/notification_manager.py,sha256=hOeFTZ8HhcFa7Ifo9aS-DUsivo5MoCTHyjmUgvH2fyY,7271
 argus/backend/service/release_manager.py,sha256=d1J6llBb4aKgFPrsPTPYpV9NnGx772jeORZjs-ojYGE,7771
-argus/backend/service/results_service.py,sha256=GYvP5x-zLHFwxLFzx8QxX2CNSNUJDf0mYu5k2Q5TcD8,7495
+argus/backend/service/results_service.py,sha256=WeVeJbOOA1KJCTw3vIUcbWE4YqldwwnTT-mYJMnUqvA,13415
 argus/backend/service/stats.py,sha256=-V94A8EUlQBvwG53oJTL4U1EzR4vciEF7Niu-efTL6Y,22713
 argus/backend/service/team_manager_service.py,sha256=zY5dvy3ffvQbJuXBvlWKE5dS5LQ3ss6tkFE-cwFZsdw,3010
-argus/backend/service/testrun.py,sha256=Erhc4iDh1VwjUDIW5YmggQ98HjB7j5UolQy1uU2SHT8,21534
+argus/backend/service/testrun.py,sha256=L9JC0D9J8D5QkuT_HxFBK_Z31j1rdiT1cRo7s4zjhqo,22251
 argus/backend/service/user.py,sha256=DC8fII7mElWGB-pMGyn4uzaJHIbmxzh_ZWf2POmlBkU,10936
 argus/backend/service/views.py,sha256=gUzwQv3fasGh0hRvivCr64XooQhG3c1V1KcxgMjC2qM,11292
 argus/backend/template_filters.py,sha256=04PHl0DiN4PBHQ82HMAmTfww09fGMXcYy-I5BU_b1s4,682
+argus/backend/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+argus/backend/tests/argus_web.test.yaml,sha256=_ompiLY3zXuGjuMenIR0UtJmkTW3RjFWejFS05o850I,1325
+argus/backend/tests/conftest.py,sha256=rg1KVQhO0wEs98HYV4kwtQxODUXq-S1MUy9_53v8qbI,1561
+argus/backend/tests/results_service/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+argus/backend/tests/results_service/test_best_results.py,sha256=JE1sOecg_TPmdcpteSUMSFx4VFwXUvyJ3736R8l7IiU,3095
 argus/backend/util/common.py,sha256=vLMit9ZBBN8S4-dw32LIhjtaEOX_5hwWneHILS_SNBg,1723
 argus/backend/util/config.py,sha256=1HpHm8Du6yz61gwAE1vR6uwuHCStaSerirbEhBLnDws,927
 argus/backend/util/encoders.py,sha256=5AfJbs2V3gOOg5LtFLZAtBqlnSdX8HHITT7r9Wu-law,1129
@@ -71,7 +76,7 @@ argus/client/driver_matrix_tests/cli.py,sha256=PIK4IyA4qku7jCnJ8A0i59DeVl1jvMWYu
 argus/client/driver_matrix_tests/client.py,sha256=UPryBku2rg6IV2wKKDkclXHnH3r6EYwWdds65wLC-KU,2748
 argus/client/generic/cli.py,sha256=IJkgEZ5VOAeqp5SlLM13Y5m8e34Cqnyz8WkfeKoN7so,2208
 argus/client/generic/client.py,sha256=l4PDjDy65Mm2OI9ZLSnyd8_2i4Ei1Pp9yRt3bRX8s2Y,1114
-argus/client/generic_result.py,sha256=yjNH_YwIx7oJWcegWWI-gd8yvnMrpLnJNpoAu9aBNjg,2962
+argus/client/generic_result.py,sha256=Fyo-ooFoO-w64BbXAlPgg0XOuuozTjv-51rAdsxecno,4197
 argus/client/generic_result_old.py,sha256=Oi15Gu8WbXK_WruF0IU-Fokr-I1k8mzg1MpHbmpt50M,4662
 argus/client/sct/client.py,sha256=DtRA0Ra3ycUcedDYfZZW1jER0nc8vdYHaY6DT0te4x0,11341
 argus/client/sct/types.py,sha256=VLgVe7qPmJtCLqtPnuX8N8kMKZq-iY3SKz68nvU6nJ4,371
@@ -84,8 +89,8 @@ argus/db/db_types.py,sha256=iLbmrUaDzrBw0kDCnvW0FSZ9-kNc3uQY-fsbIPymV4E,3612
 argus/db/interface.py,sha256=HroyA1Yijz5cXLdYbxorHCEu0GH9VeMMqB36IHTlcew,17146
 argus/db/testrun.py,sha256=0YG7FIH5FLQeNlYULxC6rhhyru2rziSMe3qKtYzTBnc,26014
 argus/db/utils.py,sha256=YAWsuLjUScSgKgdaL5aF4Sgr13gqH29Mb5cLctX4V_w,337
-argus_alm-0.12.8.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-argus_alm-0.12.8.dist-info/METADATA,sha256=Z5AqERaHlu2VBQSdQockV34Pn76P6nV5AEsjIjHQbSo,3508
-argus_alm-0.12.8.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-argus_alm-0.12.8.dist-info/entry_points.txt,sha256=pcYW8nxZuDaymxE8tn86K0dq8eEodUdiS0sSvwEQ_zU,137
-argus_alm-0.12.8.dist-info/RECORD,,
+argus_alm-0.12.9.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+argus_alm-0.12.9.dist-info/METADATA,sha256=i8u6MV6uYgTu74q8FWwy7eYWDaMmrMGrh0VNRF01-k8,3508
+argus_alm-0.12.9.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+argus_alm-0.12.9.dist-info/entry_points.txt,sha256=pcYW8nxZuDaymxE8tn86K0dq8eEodUdiS0sSvwEQ_zU,137
+argus_alm-0.12.9.dist-info/RECORD,,