utf-queue-client 1.16.0__tar.gz → 1.17.2__tar.gz

utf-queue-client-1.17.2/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.1
+Name: utf-queue-client
+Version: 1.17.2
+Home-page: 
+Author: Joe Savage
+Author-email: joe.savage@silabs.com
+Keywords: UTF,
+Requires-Python: >=3.6
+
+    No description provided
+    

{utf-queue-client-1.16.0 → utf-queue-client-1.17.2}/setup.py

@@ -2,11 +2,10 @@
 
 """
 
-
 from setuptools import setup, find_packages  # noqa: H301
 
 NAME = "utf-queue-client"
-VERSION = "1.16.0"
+VERSION = "1.17.2"
 # To install the library, run the following
 #
 # python setup.py install
@@ -54,7 +53,7 @@ setup(
             "publish_test_results_cli = utf_queue_client.scripts.publish_test_results_cli:cli_entrypoint",
             "ubai_update_retention_cli = utf_queue_client.scripts.ubai_update_retention_cli:cli_entrypoint",
             "publish_release_info_cli = utf_queue_client.scripts.publish_release_info_cli:cli_entrypoint",
-            "ubai_copy_cli = utf_queue_client.scripts.ubai_copy_cli:cli_entrypoint"
+            "ubai_copy_cli = utf_queue_client.scripts.ubai_copy_cli:cli_entrypoint",
         ],
     },
     include_package_data=True,

{utf-queue-client-1.16.0 → utf-queue-client-1.17.2}/test/test_amqp_connections.py

@@ -25,7 +25,7 @@ def queue_server(request):
     ],
 )
 def test_producer(queue_server, username, password):
-    suffix = ".dev.silabs.net"
+    suffix = ".silabs.net"
     queue_server = f"{queue_server}{suffix}"
     l = logging.getLogger("test_producer")
     l.info("Creating producer...")

utf-queue-client-1.17.2/test/test_publish_release_info.py

@@ -0,0 +1,145 @@
+import pytest
+from otel_extensions import inject_context_to_env, instrumented
+import os
+import subprocess
+import sys
+from utf_queue_client.scripts.publish_release_info_cli import publish_release_information, \
+    update_artifacts_retention_days_to_keep_forever, cli
+import requests
+from unittest import mock
+from unittest.mock import MagicMock, patch
+
+
+@pytest.fixture
+def publish_release_info():
+    yield [
+        ("releaseDate", "2023-06-16"),
+        ("branchName", "release/gecko_sdk_3.2"),
+        ("releaseType", "GA"),
+        ("releaseName", "23Q2-GA"),
+        ("SDKBuildNum", "407"),
+        ("installerURLSDK", "https://jenkins-cbs-gecko-sdk.silabs.net/job/Gecko_SDK_Suite_super/job/release%252F21q4/284/"),
+        ("IARVersionNum", "9.20.4"),
+        ("GCCVersionNum", "10.3.1"),
+        ("CommanderVersionNum", "v1.8.1"),
+        ("SEVersionNum", "1.2.4"),
+        ("WSTKFirmwareVersionNum", "v1.4.4")
+    ]
+
+
+@instrumented
+def test_publish_release_info(request, publish_release_info):
+    args = ["--username", "svc_sqabot", "--password", "password"]
+    for k, v in publish_release_info:
+        args += ["--data", k, v]
+
+    base_dir = os.path.dirname(os.path.dirname(__file__))
+    @inject_context_to_env
+    def call_cli_script():
+        assert "TRACEPARENT" in os.environ
+        process = subprocess.Popen(
+            [
+                sys.executable,
+                os.path.join(
+                    base_dir, "utf_queue_client", "scripts", "publish_release_info_cli.py"
+                ),
+            ]
+            + args,
+        )
+        process.communicate()
+        assert process.poll() == 0
+
+    call_cli_script()
+
+
+def test_publish_release_information():
+    requests_post = requests.post
+    requests.post = MagicMock()
+    publish_release_information("", "", {})
+    assert requests.post.call_count == 2
+    requests.post = requests_post
+
+
+def test_publish_release_cli_insufficient_params():
+    requests_post = requests.post
+    requests_post_mock = MagicMock()
+    requests.post = requests_post_mock
+    cli("", "", {})
+    assert requests.post.call_count == 0
+    requests.post = requests_post
+
+
+def test_publish_release_cli():
+    requests_post = requests.post
+    requests_post_mock = MagicMock()
+    requests.post = requests_post_mock
+    cli("", "", {("branchName", "test"), ("releaseData", "")})
+    assert requests_post_mock.call_count == 2
+    post_params = requests_post_mock.call_args.kwargs.get('json')
+    assert post_params.get("branchName") == "test"
+    assert post_params.get("releaseData") is None
+    requests.post = requests_post
+
+
+def test_update_artifacts_retention_days_to_keep_forever():
+    requests_patch = requests.patch
+    requests.patch = MagicMock()
+    data_dict = {"branchName": "release/gec", "SDKBuildNum": "407"}
+    update_artifacts_retention_days_to_keep_forever(data_dict)
+    assert requests.patch.call_count == 1
+    requests.patch = requests_patch
+    patch_response = MagicMock()
+    mocked_patch =mock.patch.object(requests, "patch", return_value=patch_response)
+    patch_response.status_code = 200
+    update_artifacts_retention_days_to_keep_forever(data_dict)
+
+
+@patch('requests.post')
+def test_publish_release_information_success(mock_post):
+    mock_response_auth = MagicMock()
+    mock_response_auth.json.return_value = {"access_token": "test_token"}
+    mock_response_auth.raise_for_status.return_value = None
+
+    mock_response_release = MagicMock()
+    mock_response_release.status_code = 201
+    mock_response_release.json.return_value = {"message": "success"}
+
+    mock_post.side_effect = [mock_response_auth, mock_response_release]
+
+    result = publish_release_information("test_username", "test_password", {"test_key": "test_value"})
+    assert mock_response_release.json.called
+    assert result
+
+@patch('requests.post')
+def test_publish_release_information_release_fail(mock_post):
+    # Mock the responses
+    mock_response_auth = MagicMock()
+    mock_response_auth.json.return_value = {"access_token": "test_token"}
+    mock_response_auth.raise_for_status.return_value = None
+
+    mock_response_release = MagicMock()
+    mock_response_release.status_code = 400
+    mock_response_release.text = "Release failed"
+
+    mock_post.side_effect = [mock_response_auth, mock_response_release]
+
+    result = publish_release_information("test_username", "test_password", {"test_key": "test_value"})
+    assert result is None
+
+@patch('requests.post')
+def test_publish_release_information_release_fail_422(mock_post):
+    # Mock the responses
+    mock_response_auth = MagicMock()
+    mock_response_auth.json.return_value = {"access_token": "test_token"}
+    mock_response_auth.raise_for_status.return_value = None
+
+    mock_response_release = MagicMock()
+    mock_response_release.status_code = 422
+    mock_response_release.json.return_value = {"detail": [{"loc": ["", "test_field"], "msg": "test_error"}]}
+
+    mock_post.side_effect = [mock_response_auth, mock_response_release]
+
+    # Call the function
+    result = publish_release_information("test_username", "test_password", {"test_key": "test_value"})
+    assert mock_response_release.json.called
+    assert result is None

utf-queue-client-1.17.2/test/test_rail_data_producer_tests.py

@@ -0,0 +1,64 @@
+from unittest.mock import MagicMock
+
+from utf_queue_client.clients.test_rail_data_producer import (
+    TestRailDataProducer,
+    TestRailDataProducerFactory,
+    DummyTestRailDataProducer,
+    LocalTestRailDataProducer,
+)
+import pytest
+import os
+
+
+def test_result_producer_empty_url():
+    with pytest.raises(RuntimeError):
+        _ = TestRailDataProducer()
+
+
+@pytest.mark.parametrize("queue_consumer", [60, 120], indirect=True)
+def test_result_producer_central_queue(
+    request,
+    test_rail_add_test_result,
+    amqp_url,
+    queue_consumer,
+):
+    os.environ["UTF_PRODUCER_APP_ID"] = request.node.name
+    producer = TestRailDataProducerFactory.create_producer()
+    producer.publish_add_test_result(test_rail_add_test_result)
+    queue_consumer.expect_messages(1)
+
+
+def test_dummy_producer(test_rail_add_test_result):
+    producer = DummyTestRailDataProducer()
+    producer.publish_add_test_result(test_rail_add_test_result)
+
+
+def test_local_test_rail_producer(test_rail_add_test_result, mocker):
+    mocker.patch(
+        "utf_queue_client.clients.base_producer.BlockingProducer.__init__",
+        return_value=None,
+    )
+    mocker.patch(
+        "utf_queue_client.clients.base_producer.BlockingProducer.queue_declare"
+    )
+    mock_producer_publish = mocker.patch(
+        "utf_queue_client.clients.base_producer.BlockingProducer.publish"
+    )
+    producer = LocalTestRailDataProducer()
+    producer.producer_app_id = "DUMMY"
+    producer.publish_add_test_result(test_rail_add_test_result)
+    assert mock_producer_publish.called
+    kwargs = mock_producer_publish.call_args.kwargs
+    payload = kwargs.get("payload")
+    assert payload.get("recordType") == "TEST_RAIL_EVENT"
+    assert payload.get("recordSubType") == "TEST_RESULT"
+    assert payload.get("tenantKey") == "DUMMY"
+    payload_data = payload.get("payload")
+    assert payload_data.get("version") == "v1"
+    assert payload_data.get("comment") == "testing"
+    assert payload_data.get("status") == "pass"
+    assert payload_data.get("run_id") == 1234
+    assert payload_data.get("id") == "C123"
+    custom_props = payload_data.get("custom_props")
+    assert custom_props.get("custom_interface_type") == "gcc"
+    assert custom_props.get("custom_evk_version") == "v2"

utf-queue-client-1.17.2/utf_queue_client/clients/test_rail_data_producer.py

@@ -0,0 +1,95 @@
+import os
+from .base_producer import BlockingProducer as AMQPBlockingProducer, ConnectionError
+from .http_producer import CompositeHTTPProducer
+from ..models import TestRailResult
+from ..models import QueueMessage
+from . import Loggable
+from socket import gethostname
+from datetime import datetime
+from abc import ABC, abstractmethod
+from otel_extensions import instrumented
+from typing import Optional
+
+
+__all__ = [
+    "TestRailDataProducer",
+    "DummyTestRailDataProducer",
+    "ConnectionError",
+    "TestRailDataProducerFactory",
+]
+
+
+class BaseTestRailDataProducer(ABC):
+    @abstractmethod
+    def publish_add_test_result(self, test_result: TestRailResult):
+        """publish a test result object"""
+
+
+class TestRailDataProducer(BaseTestRailDataProducer):
+    RECORD_TYPE = "TEST_RAIL_EVENT"
+
+    def __init__(
+        self,
+        url=None,
+        producer_app_id: str = None,
+        producer_class: Optional[type] = None,
+    ):
+        if producer_class is None:
+            producer_class = AMQPBlockingProducer
+        self.queue_name = "default"
+        self.__producer_client = producer_class(url, producer_app_id)
+        self.__producer_client.queue_declare(queue=self.queue_name, durable=True)
+        self.producer_app_id = producer_app_id
+
+    @instrumented
+    def publish_add_test_result(self, test_result: TestRailResult):
+        queue_message = QueueMessage(
+            payload=test_result,
+            recordType=self.RECORD_TYPE,
+            recordSubType="TEST_RESULT",
+            tenantKey=self.producer_app_id,
+            recordTimestamp=datetime.now().isoformat(),
+        )
+        queue_message.validate_schema()
+        self.__producer_client.publish(
+            exchange="",
+            routing_key=self.queue_name,
+            payload=queue_message.as_dict(),
+            persistent=True,
+        )
+
+
+class LocalTestRailDataProducer(TestRailDataProducer):
+    def __init__(self):
+        super().__init__(
+            "amqp://guest:guest@localhost:5672/%2f",
+            os.environ.get(
+                "UTF_PRODUCER_APP_ID", f"LocalTestRailDataProducer at {gethostname()}"
+            ),
+        )
+
+
+class DummyTestRailDataProducer(BaseTestRailDataProducer):
+    def publish_add_test_result(self, test_result: TestRailResult):
+        # noqa
+        pass
+
+
+class TestRailDataProducerFactory(Loggable):
+    @classmethod
+    def create_producer(cls, raise_on_connection_error=False):
+        try:
+            queue_server_url = os.environ.get("UTF_QUEUE_SERVER_URL")
+            if queue_server_url is not None:
+                return TestRailDataProducer(
+                    url=queue_server_url,
+                    producer_app_id=os.environ.get("UTF_PRODUCER_APP_ID"),
+                    producer_class=CompositeHTTPProducer,
+                )
+            else:
+                return LocalTestRailDataProducer()
+        except ConnectionError as e:
+            cls.logger.warning(f"Unable to connect to queue server: {repr(e)}")
+            if raise_on_connection_error:
+                raise
+            return DummyTestRailDataProducer()

{utf-queue-client-1.16.0 → utf-queue-client-1.17.2}/utf_queue_client/models/base_model.py

@@ -1,4 +1,6 @@
 from typing import Optional, List, Any
+from warnings import catch_warnings, filterwarnings
+
 import jsonschema
 from ..exceptions import SchemaValidationError, ValidationError
 from pydantic import (
@@ -26,10 +28,12 @@ class BaseModelWithValidation(PydanticBaseModel):
     def _set_schema(self, schema: dict, class_name: str):
         validator_class = jsonschema.validators.validator_for(schema)
         validator_class.check_schema(schema)
-        self.__validator = validator_class(
-            schema["definitions"][class_name],
-            resolver=jsonschema.RefResolver.from_schema(schema),
-        )
+        with catch_warnings():
+            filterwarnings("ignore", category=DeprecationWarning)
+            self.__validator = validator_class(
+                schema["definitions"][class_name],
+                resolver=jsonschema.RefResolver.from_schema(schema),
+            )
 
     def as_dict(self) -> dict:
         return self.dict()

utf-queue-client-1.17.2/utf_queue_client/models/schemas/utf_queue_models/models/python/generated_models.py

@@ -0,0 +1,291 @@
+# generated by datamodel-codegen:
+#   filename:  queue_message.json
+#   timestamp: 2024-03-25T08:36:22+00:00
+
+from typing import Any, Dict, List, Optional, Union
+
+from pydantic import Extra, Field, constr
+from typing_extensions import Literal
+from utf_queue_client.models.base_model import BaseModelWithValidation
+
+
+class Model(BaseModelWithValidation):
+    __root__: Any
+
+
+class QueueRecord(BaseModelWithValidation):
+    pass
+
+    class Config:
+        extra = Extra.allow
+
+
+class DataLakeData(BaseModelWithValidation):
+    dataFormat: Literal['CSV', 'JSON', 'JSONSTR', 'NDJSON', 'PARQUET']
+    object_id: Optional[str] = None
+    data: Union[Dict[str, Any], List[Dict[str, Any]], str]
+    compression: Optional[Literal['GZIP', 'NONE', 'SNAPPY']] = None
+
+
+class TelemetryData(BaseModelWithValidation):
+    dataType: Literal['LOGS', 'METRICS', 'TRACES']
+    base64ProtobufData: str
+    compression: Optional[str] = None
+
+
+class ArtifactMetadata(BaseModelWithValidation):
+    pass
+
+    class Config:
+        extra = Extra.allow
+
+
+class ArtifactBuildMetadata(BaseModelWithValidation):
+    branch: Optional[str] = None
+    stack: Optional[str] = None
+    build_number: Optional[str] = None
+    target: Optional[str] = None
+    studio: Optional[str] = None
+    compiler: Optional[str] = None
+    app_name: Optional[str] = None
+    test_suite: Optional[str] = None
+    chip_id: Optional[str] = None
+    studio_build_version: Optional[str] = None
+    compiler_build_version: Optional[str] = None
+
+
+class SqaAppBuildResult(BaseModelWithValidation):
+    session_pk_id: str = Field(
+        ...,
+        description='Logical FK to dbo.jobStatusTable.\nNot creating the constraint in case this comes in before the session record.',
+    )
+    app_name: constr(max_length=512) = Field(..., description='Name of the application')
+    app_description: Optional[constr(max_length=1024)] = Field(
+        None, description='Description of what the application does'
+    )
+    test_suite_name: Optional[constr(max_length=512)] = Field(
+        None, description='Description of the grouping of applications'
+    )
+    test_result_type: constr(max_length=256) = Field(
+        ..., description='Need table for validation created from the existing java enum'
+    )
+    executor_name: Optional[constr(max_length=256)] = Field(
+        None, description='Where the application was built'
+    )
+    feature_name: Optional[constr(max_length=256)] = Field(
+        None, description='Feature being tested by this test'
+    )
+    module_name: Optional[constr(max_length=256)] = Field(
+        None, description='Description of the device type that the application runs on'
+    )
+    phy_name: Optional[constr(max_length=256)] = Field(
+        None, description='Radio configuration used by the device'
+    )
+    test_result: Literal['FAIL', 'PASS', 'block', 'fail', 'pass', 'skip'] = Field(
+        ..., description='Did the application build'
+    )
+    engineer_name: Optional[constr(max_length=256)] = Field(
+        None, description='Name of the engineer who created the test'
+    )
+    exception_msg: Optional[str] = Field(
+        None, description='Stack dump exception message from build'
+    )
+    iot_req_id: Optional[constr(max_length=256)] = Field(
+        None, description='JIRA IOT Req Number'
+    )
+    tool_chain: Optional[constr(max_length=256)] = Field(
+        None,
+        description='Need table for validation.\nThis is the tool and version used to build the application with colon separation\niar:7.80.1',
+    )
+    notes: Optional[constr(max_length=256)] = None
+    test_duration_sec: float = Field(
+        ..., description='Length of time to build the application'
+    )
+
+
+class SqaTestResult(BaseModelWithValidation):
+    session_pk_id: str = Field(
+        ...,
+        description='Logical FK to dbo.jobStatusTable.\nNot creating the constraint in case this comes in before the session record.',
+    )
+    test_case_id: constr(max_length=512) = Field(
+        ...,
+        description='Passed in from the test executor.\nFrom the test management system or git.',
+    )
+    test_case_version_num: int
+    test_suite_name: Optional[constr(max_length=512)] = Field(
+        None, description='Named group of tests'
+    )
+    test_description: Optional[constr(max_length=1024)] = Field(
+        None, description='What does the test case actually do'
+    )
+    test_result_type: constr(max_length=256) = Field(
+        ..., description='Need to create a table for verification of this field'
+    )
+    test_parametric_data: Optional[str] = Field(
+        None, description='Test Parametric Data'
+    )
+    test_case_name: constr(max_length=512) = Field(
+        ...,
+        description='Human readable version of the test case ID\nShort summary/description',
+    )
+    executor_name: constr(max_length=256) = Field(
+        ..., description='Where the test actually ran'
+    )
+    feature_name: constr(max_length=256) = Field(
+        ..., description='Feature being tested by this test'
+    )
+    test_creation_date: str = Field(
+        ..., description='Date the test was created\nISO-8601 format'
+    )
+    testbed_name: constr(max_length=256) = Field(
+        ..., description='Grouping of all of the hardware used to execute the test'
+    )
+    module_name: constr(max_length=256) = Field(
+        ..., description='Testbed component list'
+    )
+    phy_name: Optional[constr(max_length=256)] = Field(
+        None, description='Radio configuration used by the device'
+    )
+    test_result: Literal['block', 'fail', 'metrics', 'pass', 'skip']
+    engineer_name: Optional[constr(max_length=256)] = Field(
+        None, description='Name of the engineer who created the test'
+    )
+    exception_msg: Optional[str] = Field(
+        None, description='If an error occurs, this is the message returned.'
+    )
+    iot_req_id: constr(max_length=256)
+    tool_chain: constr(max_length=256) = Field(
+        ...,
+        description='Need table for validation.\nThis is the tool and version used to build the application with colon separation\niar:7.80.1',
+    )
+    vendor_name: Optional[constr(max_length=256)] = None
+    vendor_build: Optional[constr(max_length=256)] = None
+    vendor_result: Optional[constr(max_length=256)] = None
+    notes: Optional[constr(max_length=1024)] = None
+    portal_watch: Optional[str] = Field(
+        None, description='Change this to boolean - default false'
+    )
+    test_duration_sec: float = Field(..., description='Test duration in seconds')
+    test_bed_label: Optional[constr(max_length=256)] = None
+    req_id: Optional[constr(max_length=256)] = None
+    product_line: Optional[constr(max_length=256)] = None
+    product_type: Optional[constr(max_length=256)] = None
+    customer_type: Optional[constr(max_length=256)] = None
+    jenkins_test_case_results_url: Optional[constr(max_length=1500)] = None
+    test_case_uuid: Optional[str] = Field(
+        None, description='UUID generated by the client software'
+    )
+
+
+class SqaTestSession(BaseModelWithValidation):
+    PK_ID: str = Field(..., description='UUID generated by the Jenkins client software')
+    startTime: str = Field(..., description='ISO-8601 Datetime')
+    stopTime: Optional[str] = Field(None, description='ISO-8601 datetime')
+    jenkinsJobStatus: Literal['COMPLETE', 'FAIL', 'IN PROGRESS'] = Field(
+        ..., description='Status of the Jenkins job'
+    )
+    duration: Optional[int] = Field(
+        None,
+        description='Elapsed number of seconds for the Jenkins job.\nShould be close to stop time - start time.\nChange the data type in the DB to integer.',
+    )
+    jobType: Optional[constr(max_length=256)] = Field(
+        None, description='Type of Jenkins job'
+    )
+    releaseName: constr(max_length=256)
+    branchName: constr(max_length=256)
+    stackName: constr(max_length=256)
+    SDKBuildNum: int
+    SDKUrl: Optional[constr(max_length=1500)] = None
+    studioUrl: Optional[constr(max_length=1500)] = None
+    totalTests: Optional[int] = None
+    PASS_cnt: Optional[int] = None
+    FAIL_cnt: Optional[int] = None
+    SKIP_cnt: Optional[int] = None
+    BLOCK_cnt: Optional[int] = None
+    jenkinsServerName: constr(max_length=256)
+    jenkinRunNum: int
+    jenkinsJobName: constr(max_length=1500)
+    jenkinsTestResultsUrl: constr(max_length=1500)
+    traceId: Optional[constr(max_length=500)] = None
+    testFramework: Optional[constr(max_length=256)] = None
+    SDKVersion: Optional[constr(max_length=256)] = None
+    test_run_by: Optional[constr(max_length=256)] = None
+
+
+class LogEvent(BaseModelWithValidation):
+    pass
+
+
+class ExceptionEvent(BaseModelWithValidation):
+    pass
+
+
+class TestResultCustomProps(BaseModelWithValidation):
+    pass
+
+    class Config:
+        extra = Extra.allow
+
+
+class QueueMessage(BaseModelWithValidation):
+    recordType: Literal[
+        'ARTIFACT_UPLOAD_REQUEST',
+        'DATALAKE_DATA',
+        'EXCEPTION_EVENT',
+        'LOG_EVENT',
+        'OPENTELEMETRY_DATA',
+        'TEST_RAIL_EVENT',
+        'UTF_TEST_EVENT',
+    ] = Field(..., description='Type of record')
+    recordSubType: Optional[
+        Literal['BUILD_RESULT', 'SESSION_START', 'SESSION_STOP', 'TEST_RESULT']
+    ] = Field(
+        None,
+        description='Subtype of record. Not all types have a subtype, but it is required when they have one.',
+    )
+    tenantKey: str = Field(
+        ...,
+        description='Unique string that identifies the app/group sending the message.\nForward looking to match the data lake infrastructure.',
+    )
+    recordTimestamp: str = Field(
+        ...,
+        description='UTC datetime.\nUse ISO-8601 format with time zone\n2022-03-10T18:50:05Z',
+    )
+    payload: 'QueueRecord' = Field(
+        ...,
+        description='Record Payload.\nThis is flexible to allow different fields for different record types and DB tables',
+    )
+
+
+class QueueMessageV1(BaseModelWithValidation):
+    recordType: Literal[
+        'ARTIFACT_UPLOAD_REQUEST',
+        'EXCEPTION_EVENT',
+        'LOG_EVENT',
+        'TEST_EVENT',
+        'UTF_TEST_EVENT',
+    ] = Field(..., description='Type of record')
+    payload: 'QueueRecord' = Field(..., description='Record Payload')
+    timestamp: float = Field(
+        ..., description='UTC Timestamp\nGiven in seconds since epoch (unix time)'
+    )
+
+
+class ArtifactUploadRequest(BaseModelWithValidation):
+    name: str
+    extension: str
+    metadata: Union['ArtifactMetadata', 'ArtifactBuildMetadata']
+    base64Content: str
+    validateMetadata: bool
+
+
+class TestRailResult(BaseModelWithValidation):
+    id: str
+    run_id: int
+    status: str
+    comment: Optional[str] = None
+    version: Optional[str] = None
+    defects: Optional[str] = None
+    assigned_to_id: Optional[int] = None
+    custom_props: Optional['TestResultCustomProps'] = None