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

qase/commons/models/attachment.py

@@ -29,16 +29,19 @@ class Attachment(BaseModel):
     def get_id(self) -> str:
         return self.id
 
-    def get_for_upload(self) -> BytesIO:
+    def get_for_upload(self) -> tuple:
+        """Returns attachment data in format expected by new API client: (filename, filedata)"""
+        
         if self.file_path:
             with open(self.file_path, "rb") as fc:
-                content = BytesIO(fc.read())
+                filedata = fc.read()
         else:
             if isinstance(self.content, str):
-                content = BytesIO(bytes(self.content, 'utf-8'))
+                filedata = bytes(self.content, 'utf-8')
             elif isinstance(self.content, bytes):
-                content = BytesIO(self.content)
-        content.name = self.file_name
-        content.mime = self.mime_type
-
-        return content
+                filedata = self.content
+            else:
+                # Handle case where content is not str or bytes (e.g., JSON serialized)
+                filedata = bytes(self.content, 'utf-8')
+        
+        return (self.file_name, filedata)

qase/commons/models/config/qaseconfig.py

@@ -1,4 +1,5 @@
 from enum import Enum
+from typing import List, Dict, Optional
 
 from .framework import Framework
 from .report import ReportConfig
@@ -13,6 +14,21 @@ class Mode(Enum):
     off = "off"
 
 
+class LoggingConfig(BaseModel):
+    console: Optional[bool] = None
+    file: Optional[bool] = None
+
+    def __init__(self):
+        self.console = None
+        self.file = None
+
+    def set_console(self, console: bool):
+        self.console = console
+
+    def set_file(self, file: bool):
+        self.file = file
+
+
 class ExecutionPlan(BaseModel):
     path: str = None
 
@@ -34,6 +50,9 @@ class QaseConfig(BaseModel):
     report: ReportConfig = None
     profilers: list = None
     framework: Framework = None
+    exclude_params: list = None
+    status_mapping: Dict[str, str] = None
+    logging: LoggingConfig = None
 
     def __init__(self):
         self.mode = Mode.off
@@ -44,6 +63,9 @@ class QaseConfig(BaseModel):
         self.execution_plan = ExecutionPlan()
         self.framework = Framework()
         self.profilers = []
+        self.exclude_params = []
+        self.status_mapping = {}
+        self.logging = LoggingConfig()
 
     def set_mode(self, mode: str):
         if any(mode == e.value for e in Mode.__members__.values()):
@@ -64,3 +86,15 @@ class QaseConfig(BaseModel):
 
     def set_debug(self, debug):
         self.debug = QaseUtils.parse_bool(debug)
+
+    def set_exclude_params(self, exclude_params: List[str]):
+        self.exclude_params = exclude_params
+
+    def set_status_mapping(self, status_mapping: Dict[str, str]):
+        self.status_mapping = status_mapping
+
+    def set_logging(self, logging_config: dict):
+        if logging_config.get("console") is not None:
+            self.logging.set_console(QaseUtils.parse_bool(logging_config.get("console")))
+        if logging_config.get("file") is not None:
+            self.logging.set_file(QaseUtils.parse_bool(logging_config.get("file")))

qase/commons/models/config/run.py

@@ -1,4 +1,6 @@
+from typing import List, Optional
 from ..basemodel import BaseModel
+from ..external_link import ExternalLinkConfig
 from ... import QaseUtils
 
 
@@ -7,9 +9,14 @@ class RunConfig(BaseModel):
     description: str = None
     complete: bool = None
     id: int = None
+    tags: List[str] = None
+    external_link: Optional[ExternalLinkConfig] = None
+
 
     def __init__(self):
         self.complete = True
+        self.tags = []
+        self.external_link = None
 
     def set_title(self, title: str):
         self.title = title
@@ -22,3 +29,15 @@ class RunConfig(BaseModel):
 
     def set_id(self, id: int):
         self.id = id
+
+    def set_tags(self, tags: List[str]):
+        self.tags = tags
+
+    def set_external_link(self, external_link: dict):
+        """Set external link configuration from dictionary"""
+        if external_link:
+            self.external_link = ExternalLinkConfig()
+            if 'type' in external_link:
+                self.external_link.set_type(external_link['type'])
+            if 'link' in external_link:
+                self.external_link.set_link(external_link['link'])

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,16 +47,28 @@ 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.status_filter = []
+        self.show_public_report_link = False
 
     def set_project(self, project: str):
         self.project = project
 
     def set_defect(self, defect):
         self.defect = QaseUtils.parse_bool(defect)
+
+    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/result.py

@@ -25,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
@@ -33,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)
 
 

qase/commons/models/run.py

@@ -24,6 +24,7 @@ class RunStats(BaseModel):
         self.failed = 0
         self.skipped = 0
         self.broken = 0
+        self.invalid = 0
         self.muted = 0
         self.total = 0
 
@@ -37,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

qase/commons/models/runtime.py

@@ -1,3 +1,4 @@
+from . import Result
 from .step import Step
 from .attachment import Attachment
 
@@ -42,6 +43,14 @@ class Runtime:
         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 = {}

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):
@@ -43,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
@@ -56,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):
@@ -75,20 +103,20 @@ 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):

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
+]