qase-python-commons 3.1.3__py3-none-any.whl → 4.1.3__py3-none-any.whl

qase/commons/models/config/testops.py

@@ -4,6 +4,40 @@ from .plan import PlanConfig
 from .run import RunConfig
 from ..basemodel import BaseModel
 from ... import QaseUtils
+from typing import List
+
+
+class ConfigurationValue(BaseModel):
+    name: str = None
+    value: str = None
+
+    def __init__(self, name: str = None, value: str = None):
+        self.name = name
+        self.value = value
+
+    def set_name(self, name: str):
+        self.name = name
+
+    def set_value(self, value: str):
+        self.value = value
+
+
+class ConfigurationsConfig(BaseModel):
+    values: List[ConfigurationValue] = None
+    create_if_not_exists: bool = None
+
+    def __init__(self):
+        self.values = []
+        self.create_if_not_exists = False
+
+    def set_values(self, values: List[ConfigurationValue]):
+        self.values = values
+
+    def set_create_if_not_exists(self, create_if_not_exists):
+        self.create_if_not_exists = QaseUtils.parse_bool(create_if_not_exists)
+
+    def add_value(self, name: str, value: str):
+        self.values.append(ConfigurationValue(name=name, value=value))
 
 
 class TestopsConfig(BaseModel):
@@ -13,14 +47,19 @@ class TestopsConfig(BaseModel):
     run: RunConfig = None
     plan: PlanConfig = None
     batch: BatchConfig = None
+    configurations: ConfigurationsConfig = None
+    status_filter: List[str] = None
+    show_public_report_link: bool = None
 
     def __init__(self):
         self.api = ApiConfig()
         self.run = RunConfig()
         self.batch = BatchConfig()
         self.plan = PlanConfig()
+        self.configurations = ConfigurationsConfig()
         self.defect = False
-        self.use_v2 = False
+        self.status_filter = []
+        self.show_public_report_link = False
 
     def set_project(self, project: str):
         self.project = project
@@ -28,5 +67,8 @@ class TestopsConfig(BaseModel):
     def set_defect(self, defect):
         self.defect = QaseUtils.parse_bool(defect)
 
-    def set_use_v2(self, use_v2):
-        self.use_v2 = QaseUtils.parse_bool(use_v2)
+    def set_status_filter(self, status_filter: List[str]):
+        self.status_filter = status_filter
+
+    def set_show_public_report_link(self, show_public_report_link):
+        self.show_public_report_link = QaseUtils.parse_bool(show_public_report_link)

qase/commons/models/external_link.py

@@ -0,0 +1,41 @@
+from enum import Enum
+from typing import Optional
+from .basemodel import BaseModel
+
+
+class ExternalLinkType(Enum):
+    """External link types supported by Qase TestOps"""
+    JIRA_CLOUD = 'jiraCloud'
+    JIRA_SERVER = 'jiraServer'
+
+
+class ExternalLinkConfig(BaseModel):
+    """Configuration for external link"""
+    type: ExternalLinkType = None
+    link: str = None
+
+    def __init__(self, type: ExternalLinkType = None, link: str = None):
+        self.type = type
+        self.link = link
+
+    def set_type(self, type: str):
+        """Set external link type from string"""
+        if type == 'jiraCloud':
+            self.type = ExternalLinkType.JIRA_CLOUD
+        elif type == 'jiraServer':
+            self.type = ExternalLinkType.JIRA_SERVER
+        else:
+            raise ValueError(f"Invalid external link type: {type}. Supported types: jiraCloud, jiraServer")
+
+    def set_link(self, link: str):
+        """Set external link URL or identifier"""
+        self.link = link
+
+    def to_api_type(self) -> str:
+        """Convert to API enum value"""
+        if self.type == ExternalLinkType.JIRA_CLOUD:
+            return 'jira-cloud'
+        elif self.type == ExternalLinkType.JIRA_SERVER:
+            return 'jira-server'
+        else:
+            raise ValueError(f"Invalid external link type: {self.type}")

qase/commons/models/relation.py

@@ -1,13 +1,23 @@
 from .basemodel import BaseModel
 
 
-class RelationSuite(BaseModel):
-    def __init__(self, suite_id: int, title: str) -> None:
-        self.suite_id = suite_id
+class SuiteData(BaseModel):
+    def __init__(self, title: str) -> None:
+        self.public_id = None
         self.title = title
 
 
+class RelationSuite(BaseModel):
+    def __init__(self) -> None:
+        self.data = []
+
+    def add_data(self, data: SuiteData) -> None:
+        self.data.append(data)
+
+
 class Relation(BaseModel):
-    def __init__(self, type: str, data: RelationSuite):
-        self.type = type
-        self.data = data
+    def __init__(self):
+        self.suite = RelationSuite()
+
+    def add_suite(self, suite: SuiteData) -> None:
+        self.suite.add_data(suite)

qase/commons/models/result.py

@@ -4,7 +4,6 @@ import uuid
 from typing import Type, Optional, Union, Dict, List
 from .basemodel import BaseModel
 from .step import Step
-from .suite import Suite
 from .attachment import Attachment
 from .relation import Relation
 from .. import QaseUtils
@@ -26,7 +25,7 @@ class Execution(BaseModel):
                  stacktrace: Optional[str] = None,
                  thread: Optional[str] = QaseUtils.get_thread_name()
                  ):
-        self.start_time = time.time()
+        self.start_time = QaseUtils.get_real_time()
         self.status = status
         self.end_time = end_time
         self.duration = duration
@@ -34,16 +33,22 @@ class Execution(BaseModel):
         self.thread = thread
 
     def set_status(self, status: Optional[str]):
-        if status in ['passed', 'failed', 'skipped', 'untested']:
+        if status is None:
             self.status = status
+            return
+        
+        # Convert to lowercase for validation
+        status_lower = status.lower()
+        if status_lower in ['passed', 'failed', 'skipped', 'untested', 'invalid', 'disabled', 'blocked']:
+            self.status = status_lower
         else:
-            raise ValueError('Step status must be one of: passed, failed, skipped, untested')
+            raise ValueError('Step status must be one of: passed, failed, skipped, untested, invalid, disabled, blocked')
 
     def get_status(self):
         return self.status
 
     def complete(self):
-        self.end_time = time.time()
+        self.end_time = QaseUtils.get_real_time()
         self.duration = (int)((self.end_time - self.start_time) * 1000)
 
 
@@ -70,20 +75,16 @@ class Result(BaseModel):
         self.id: str = str(uuid.uuid4())
         self.title: str = title
         self.signature: str = signature
-        self.run_id: Optional[str] = None
-        self.testops_id: Optional[int] = None
+        self.testops_ids: Optional[List[int]] = None
         self.execution: Type[Execution] = Execution()
         self.fields: Dict[Type[Field]] = {}
         self.attachments: List[Attachment] = []
         self.steps: List[Type[Step]] = []
         self.params: Optional[dict] = {}
         self.param_groups: Optional[List[List[str]]] = []
-        self.author: Optional[str] = None
-        self.relations: List[Type[Relation]] = []
+        self.relations: Type[Relation] = None
         self.muted: bool = False
         self.message: Optional[str] = None
-        self.suite: Optional[Type[Suite]] = None
-        QaseUtils.get_host_data()
 
     def add_message(self, message: str) -> None:
         self.message = message
@@ -97,20 +98,14 @@ class Result(BaseModel):
     def add_attachment(self, attachment: Attachment) -> None:
         self.attachments.append(attachment)
 
-    def add_relation(self, relation: Type[Relation]) -> None:
-        self.relations.append(relation)
-
     def add_param(self, key: str, value: str) -> None:
         self.params[key] = value
 
     def add_param_groups(self, values: List[str]) -> None:
         self.param_groups.append(values)
 
-    def add_relation(self, relation: Type[Relation]) -> None:
-        self.relations.append(relation)
-
-    def add_suite(self, suite: Type[Suite]) -> None:
-        self.suite = suite
+    def set_relation(self, relation: Relation) -> None:
+        self.relations = relation
 
     def get_status(self) -> Optional[str]:
         return self.execution.status
@@ -126,18 +121,8 @@ class Result(BaseModel):
             return self.fields[name]
         return None
 
-    def get_testops_id(self) -> Optional[int]:
-        if self.testops_id is None:
-            # Hack for old API
-            return 0
-        return self.testops_id
+    def get_testops_ids(self) -> Optional[List[int]]:
+        return self.testops_ids
 
     def get_duration(self) -> int:
         return self.execution.duration
-
-    def get_suite_title(self) -> Optional[str]:
-        if self.suite:
-            return self.suite.title
-
-    def set_run_id(self, run_id: str) -> None:
-        self.run_id = run_id

qase/commons/models/run.py

@@ -1,5 +1,3 @@
-import json
-
 from typing import Optional, List
 
 from .basemodel import BaseModel
@@ -26,6 +24,7 @@ class RunStats(BaseModel):
         self.failed = 0
         self.skipped = 0
         self.broken = 0
+        self.invalid = 0
         self.muted = 0
         self.total = 0
 
@@ -39,6 +38,8 @@ class RunStats(BaseModel):
             self.skipped += 1
         elif status == "broken":
             self.broken += 1
+        elif status == "invalid":
+            self.invalid += 1
         self.total += 1
         if result.get('muted', False):
             self.muted += 1
@@ -71,6 +72,7 @@ class Run(BaseModel):
             "duration": result["execution"]["duration"],
             "thread": result["execution"]["thread"]
         }
+        self._extract_path_from_relations(result)
         self.results.append(compact_result)
         self.execution.track(result)
         self.stats.track(result)
@@ -79,3 +81,16 @@ class Run(BaseModel):
 
     def add_host_data(self, host_data: dict):
         self.host_data = host_data
+
+    def _extract_path_from_relations(self, relations_dict):
+
+        titles = []
+        if "relations" in relations_dict and "suite" in relations_dict["relations"]:
+            if "data" in relations_dict["relations"]["suite"]:
+                data_list = relations_dict["relations"]["suite"]["data"]
+                titles = [item["title"] for item in data_list if "title" in item]
+
+        path = "/".join(titles)
+
+        if path and path not in self.suites:
+            self.suites.append(path)

qase/commons/models/runtime.py

@@ -1,4 +1,5 @@
-from .step import Step, StepTextData
+from . import Result
+from .step import Step
 from .attachment import Attachment
 
 
@@ -41,3 +42,16 @@ class Runtime:
                 self.result.add_attachment(attachment)
         except Exception as e:
             raise QaseRuntimeException(e)
+
+
+    def add_param(self, key: str, value: str):
+        """
+        Add a parameter to the current result.
+        """
+        if self.result is not None:
+            self.result.params[key] = value
+
+    def clear(self):
+        self.result = None
+        self.steps = {}
+        self.step_id = None

qase/commons/models/step.py

@@ -5,6 +5,7 @@ from enum import Enum
 from typing import Optional, Union, Dict, List, Type
 from .attachment import Attachment
 from .basemodel import BaseModel
+from .. import QaseUtils
 
 
 class StepType(Enum):
@@ -20,6 +21,7 @@ class StepTextData(BaseModel):
     def __init__(self, action: str, expected_result: Optional[str] = None):
         self.action = action
         self.expected_result = expected_result
+        self.input_data = None
 
 
 class StepAssertData(BaseModel):
@@ -42,10 +44,20 @@ class StepRequestData(BaseModel):
         self.response_body = None
         self.status_code = None
         if isinstance(request_body, bytes):
-            request_body = request_body.decode('utf-8')
+            try:
+                request_body = request_body.decode('utf-8')
+            except UnicodeDecodeError:
+                # For binary data (like file uploads), keep as base64 encoded string
+                import base64
+                request_body = base64.b64encode(request_body).decode('ascii')
         self.request_body = request_body
         if isinstance(request_headers, bytes):
-            request_headers = request_headers.decode('utf-8')
+            try:
+                request_headers = request_headers.decode('utf-8')
+            except UnicodeDecodeError:
+                # For binary headers, keep as base64 encoded string
+                import base64
+                request_headers = base64.b64encode(request_headers).decode('ascii')
         self.request_headers = request_headers
         self.request_method = request_method
         self.request_url = request_url
@@ -55,16 +67,33 @@ class StepRequestData(BaseModel):
         self.status_code = status_code
 
         if isinstance(response_body, bytes):
-            response_body = response_body.decode('utf-8')
+            try:
+                response_body = response_body.decode('utf-8')
+            except UnicodeDecodeError:
+                # For binary data (like file downloads), keep as base64 encoded string
+                import base64
+                response_body = base64.b64encode(response_body).decode('ascii')
         self.response_body = response_body
         if isinstance(response_headers, bytes):
-            response_headers = response_headers.decode('utf-8')
+            try:
+                response_headers = response_headers.decode('utf-8')
+            except UnicodeDecodeError:
+                # For binary headers, keep as base64 encoded string
+                import base64
+                response_headers = base64.b64encode(response_headers).decode('ascii')
         self.response_headers = response_headers
 
 
 class StepDbQueryData(BaseModel):
-    def __init__(self, query: str, expected_result: str):
+    def __init__(self, query: str, expected_result: str = None, 
+                 database_type: str = None, execution_time: float = None,
+                 rows_affected: int = None, connection_info: str = None):
         self.query = query
+        self.expected_result = expected_result
+        self.database_type = database_type
+        self.execution_time = execution_time
+        self.rows_affected = rows_affected
+        self.connection_info = connection_info
 
 
 class StepSleepData(BaseModel):
@@ -74,21 +103,25 @@ class StepSleepData(BaseModel):
 
 class StepExecution(BaseModel):
     def __init__(self, status: Optional[str] = 'untested', end_time: int = 0, duration: int = 0):
-        self.start_time = time.time()
+        self.start_time = QaseUtils.get_real_time()
         self.status = status
         self.end_time = end_time
         self.duration = duration
+        self.attachments = []
 
     def set_status(self, status: Optional[str]):
-        if status in ['passed', 'failed', 'skipped', 'blocked', 'untested']:
+        if status in ['passed', 'failed', 'skipped', 'blocked', 'untested', 'invalid']:
             self.status = status
         else:
-            raise ValueError('Step status must be one of: passed, failed, skipped, blocked, untested')
+            raise ValueError('Step status must be one of: passed, failed, skipped, blocked, untested, invalid')
 
     def complete(self):
-        self.end_time = time.time()
+        self.end_time = QaseUtils.get_real_time()
         self.duration = int((self.end_time - self.start_time) * 1000)
 
+    def add_attachment(self, attachment: Attachment):
+        self.attachments.append(attachment)
+
 
 class Step(BaseModel):
     def __init__(self,
@@ -107,7 +140,6 @@ class Step(BaseModel):
         self.data = data
         self.parent_id = parent_id
         self.execution = StepExecution()
-        self.attachments = []
         self.steps = []
 
     def set_parent_id(self, parent_id: Optional[str]):
@@ -132,4 +164,4 @@ class Step(BaseModel):
         self.steps = steps
 
     def add_attachment(self, attachment: Attachment):
-        self.attachments.append(attachment)
+        self.execution.add_attachment(attachment)

qase/commons/profilers/__init__.py

@@ -1,10 +1,11 @@
 from .network import NetworkProfiler, NetworkProfilerSingleton
 from .sleep import SleepProfiler
-from .db import DbProfiler
+from .db import DatabaseProfiler, DatabaseProfilerSingleton
 
 __all__ = [
     NetworkProfiler,
     NetworkProfilerSingleton,
     SleepProfiler,
-    DbProfiler
-]
+    DatabaseProfiler,
+    DatabaseProfilerSingleton
+]