qase-python-commons 3.1.9__py3-none-any.whl → 4.1.9__py3-none-any.whl

qase/commons/logger.py

@@ -1,32 +1,101 @@
+import os
 import datetime
+import threading
+from typing import Optional
 
-import os
+
+class LoggingOptions:
+    def __init__(self, console: bool = True, file: bool = False):
+        self.console = console
+        self.file = file
 
 
 class Logger:
-    def __init__(self, debug: bool = False, prefix: str = '', dir: str = os.path.join('.', 'logs')) -> None:
+    _log_file = None
+
+    def __init__(self, debug: bool = False, prefix: str = '', dir: str = os.path.join('.', 'logs'), 
+                 logging_options: Optional[LoggingOptions] = None) -> None:
         self.debug = debug
-        if self.debug:
-            filename = f'{prefix}_{self._get_timestamp()}.log'
-            if not os.path.exists(dir):
-                os.makedirs(dir)
-            self.log_file = os.path.join(dir, f'{filename}')
-            with open(self.log_file, 'w', encoding='utf-8'):
+        self.prefix = prefix
+        self.dir = dir
+        
+        # Initialize logging options
+        if logging_options is None:
+            # Default behavior: console always enabled, file enabled only in debug mode
+            self.logging_options = LoggingOptions(
+                console=True,
+                file=debug
+            )
+        else:
+            self.logging_options = logging_options
+        
+        # Override with environment variables if set
+        self._load_env_logging_options()
+        
+        # Setup file logging if enabled
+        if self.logging_options.file:
+            if Logger._log_file is None:
+                timestamp = self._get_timestamp()
+                filename = f'{prefix}_{timestamp}.log'
+                if not os.path.exists(dir):
+                    os.makedirs(dir)
+                Logger._log_file = os.path.join(dir, filename)
+
+            with open(Logger._log_file, 'a', encoding='utf-8'):
                 pass
 
+            self.lock = threading.Lock()
+
+    def _load_env_logging_options(self):
+        """Load logging options from environment variables"""
+        # QASE_LOGGING_CONSOLE
+        console_env = os.environ.get('QASE_LOGGING_CONSOLE')
+        if console_env is not None:
+            self.logging_options.console = console_env.lower() in ('true', '1', 'yes', 'on')
+        
+        # QASE_LOGGING_FILE
+        file_env = os.environ.get('QASE_LOGGING_FILE')
+        if file_env is not None:
+            self.logging_options.file = file_env.lower() in ('true', '1', 'yes', 'on')
+        
+        # Legacy QASE_DEBUG support
+        debug_env = os.environ.get('QASE_DEBUG')
+        if debug_env is not None and debug_env.lower() in ('true', '1', 'yes', 'on'):
+            # When debug is enabled via env, enable file logging if not explicitly disabled
+            if not hasattr(self.logging_options, 'file') or self.logging_options.file is None:
+                self.logging_options.file = True
+
     def log(self, message: str, level: str = 'info'):
         time_str = self._get_timestamp("%H:%M:%S")
         log = f"[Qase][{time_str}][{level}] {message}\n"
-        print(log)
-        if self.debug:
-            with open(self.log_file, 'a', encoding='utf-8') as f:
-                f.write(log)
+
+        # Console output
+        if self.logging_options.console:
+            try:
+                print(log, end='')
+            except (OSError, IOError):
+                pass
+
+        # File output
+        if self.logging_options.file:
+            with self.lock:
+                with open(Logger._log_file, 'a', encoding='utf-8') as f:
+                    f.write(log)
 
     def log_debug(self, message: str):
         if self.debug:
             self.log(message, 'debug')
 
+    def log_error(self, message: str):
+        self.log(message, 'error')
+
+    def log_warning(self, message: str):
+        self.log(message, 'warning')
+
+    def log_info(self, message: str):
+        self.log(message, 'info')
+
     @staticmethod
-    def _get_timestamp(fmt: str = "%Y%m%d_%H_%M_%S"):
+    def _get_timestamp(fmt: str = "%Y%m%d"):
         now = datetime.datetime.now()
         return now.strftime(fmt)

qase/commons/models/__init__.py

@@ -1,7 +1,6 @@
 from .result import Result, Field
 from .run import Run
 from .attachment import Attachment
-from .suite import Suite
 from .relation import Relation
 from .step import Step
 from .runtime import Runtime
@@ -10,7 +9,6 @@ __all__ = [
     Result,
     Run,
     Attachment,
-    Suite,
     Relation,
     Step,
     Runtime,

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/basemodel.py

@@ -1,7 +1,16 @@
 import json
 
+from enum import Enum
+
 
 class BaseModel:
-    def __str__(self) -> str:
-        return json.dumps(self, default=lambda o: o.__dict__ if hasattr(o, '__dict__') else str(o), indent=4,
-                          sort_keys=True)
+    def __str__(self, enum_as_name=False) -> str:
+        def serialize(o):
+            if isinstance(o, Enum):
+                return o.name if enum_as_name else o.value
+            elif hasattr(o, '__dict__'):
+                return o.__dict__
+            else:
+                return str(o)
+
+        return json.dumps(self, default=serialize, indent=4, sort_keys=True)

qase/commons/models/config/framework.py

@@ -17,11 +17,28 @@ class Trace(Enum):
     failed = "retain-on-failure"
 
 
+class XFailStatus(BaseModel):
+    xfail: str = None
+    xpass: str = None
+
+    def __init__(self):
+        self.xfail = 'skipped'
+        self.xpass = 'passed'
+
+    def set_xfail(self, value: str):
+        self.xfail = value
+
+    def set_xpass(self, value: str):
+        self.xpass = value
+
+
 class PytestConfig(BaseModel):
     capture_logs: bool = None
+    xfail_status: XFailStatus = None
 
     def __init__(self):
         self.capture_logs = False
+        self.xfail_status = XFailStatus()
 
     def set_capture_logs(self, capture_logs):
         self.capture_logs = QaseUtils.parse_bool(capture_logs)

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,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,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 = {}