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

qase/commons/config.py

@@ -1,18 +1,28 @@
 import os
 import json
-from .logger import Logger
+from .logger import Logger, LoggingOptions
 from .models.config.qaseconfig import QaseConfig, Mode
+from .utils import QaseUtils
 
 
 class ConfigManager:
 
     def __init__(self, config_file='./qase.config.json'):
-        self.logger = Logger()
         self.__config_file = config_file
         self.config = QaseConfig()
 
+        # Initialize temporary logger for error handling during config loading
+        self.logger = Logger(debug=False)
+        
         self.__load_file_config()
         self.__load_env_config()
+        
+        # Re-initialize logger with proper logging options after config is loaded
+        logging_options = LoggingOptions(
+            console=self.config.logging.console if self.config.logging.console is not None else True,
+            file=self.config.logging.file if self.config.logging.file is not None else self.config.debug
+        )
+        self.logger = Logger(debug=self.config.debug, logging_options=logging_options)
 
     def validate_config(self):
         errors: list[str] = []
@@ -53,15 +63,26 @@ class ConfigManager:
                     if config.get("profilers"):
                         self.config.set_profilers(config.get("profilers"))
 
-                    if config.get("debug"):
+                    if config.get("debug") is not None:
                         self.config.set_debug(
                             config.get("debug")
                         )
 
+                    if config.get("excludeParams"):
+                        self.config.set_exclude_params(
+                            config.get("excludeParams")
+                        )
+
+                    if config.get("statusMapping"):
+                        self.config.set_status_mapping(
+                            config.get("statusMapping")
+                        )
+
                     if config.get("executionPlan"):
                         execution_plan = config.get("executionPlan")
                         if execution_plan.get("path"):
-                            self.config.execution_plan.set_path(execution_plan.get("path"))
+                            self.config.execution_plan.set_path(
+                                execution_plan.get("path"))
 
                     if config.get("testops"):
                         testops = config.get("testops")
@@ -70,24 +91,22 @@ class ConfigManager:
                             api = testops.get("api")
 
                             if api.get("host"):
-                                self.config.testops.api.set_host(api.get("host"))
+                                self.config.testops.api.set_host(
+                                    api.get("host"))
 
                             if api.get("token"):
-                                self.config.testops.api.set_token(api.get("token"))
+                                self.config.testops.api.set_token(
+                                    api.get("token"))
 
                         if testops.get("project"):
-                            self.config.testops.set_project(testops.get("project"))
+                            self.config.testops.set_project(
+                                testops.get("project"))
 
-                        if testops.get("defect"):
+                        if testops.get("defect") is not None:
                             self.config.testops.set_defect(
                                 testops.get("defect")
                             )
 
-                        if testops.get("useV2"):
-                            self.config.testops.set_use_v2(
-                                testops.get("useV2")
-                            )
-
                         if testops.get("plan"):
                             plan = testops.get("plan")
 
@@ -101,21 +120,59 @@ class ConfigManager:
                                 self.config.testops.run.set_id(run.get("id"))
 
                             if run.get("title"):
-                                self.config.testops.run.set_title(run.get("title"))
+                                self.config.testops.run.set_title(
+                                    run.get("title"))
 
                             if run.get("description"):
-                                self.config.testops.run.set_description(run.get("description"))
+                                self.config.testops.run.set_description(
+                                    run.get("description"))
 
-                            if run.get("complete"):
+                            if run.get("complete") is not None:
                                 self.config.testops.run.set_complete(
                                     run.get("complete")
                                 )
 
+                            if run.get("tags"):
+                                self.config.testops.run.set_tags(
+                                    [tag.strip() for tag in run.get("tags")])
+
+                            if run.get("externalLink"):
+                                self.config.testops.run.set_external_link(
+                                    run.get("externalLink"))
+
                         if testops.get("batch"):
                             batch = testops.get("batch")
 
                             if batch.get("size"):
-                                self.config.testops.batch.set_size(batch.get("size"))
+                                self.config.testops.batch.set_size(
+                                    batch.get("size"))
+
+                        if testops.get("configurations"):
+                            configurations = testops.get("configurations")
+
+                            if configurations.get("values"):
+                                values = configurations.get("values")
+                                for value in values:
+                                    if value.get("name") and value.get("value"):
+                                        self.config.testops.configurations.add_value(
+                                            value.get("name"), value.get("value"))
+
+                            if configurations.get("createIfNotExists") is not None:
+                                self.config.testops.configurations.set_create_if_not_exists(
+                                    configurations.get("createIfNotExists"))
+
+                        if testops.get("statusFilter"):
+                            status_filter = testops.get("statusFilter")
+                            if isinstance(status_filter, list):
+                                self.config.testops.set_status_filter(status_filter)
+                            elif isinstance(status_filter, str):
+                                # Parse comma-separated string
+                                self.config.testops.set_status_filter([s.strip() for s in status_filter.split(',')])
+
+                        if testops.get("showPublicReportLink") is not None:
+                            self.config.testops.set_show_public_report_link(
+                                testops.get("showPublicReportLink")
+                            )
 
                     if config.get("report"):
                         report = config.get("report")
@@ -127,7 +184,8 @@ class ConfigManager:
                             connection = report.get("connection")
 
                             if connection.get("path"):
-                                self.config.report.connection.set_path(connection.get("path"))
+                                self.config.report.connection.set_path(
+                                    connection.get("path"))
 
                             if connection.get("format"):
                                 self.config.report.connection.set_format(
@@ -140,11 +198,27 @@ class ConfigManager:
                         if framework.get("pytest"):
                             pytest = framework.get("pytest")
 
-                            if pytest.get("captureLogs"):
+                            if pytest.get("captureLogs") is not None:
                                 self.config.framework.pytest.set_capture_logs(
                                     pytest.get("captureLogs")
                                 )
 
+                            if pytest.get("xfailStatus"):
+                                xfail_status = pytest.get("xfailStatus")
+
+                                if xfail_status.get("xfail"):
+                                    self.config.framework.pytest.xfail_status.set_xfail(
+                                        xfail_status.get("xfail")
+                                    )
+
+                                if xfail_status.get("xpass"):
+                                    self.config.framework.pytest.xfail_status.set_xpass(
+                                        xfail_status.get("xpass")
+                                    )
+
+                    if config.get("logging"):
+                        self.config.set_logging(config.get("logging"))
+
         except Exception as e:
             self.logger.log("Failed to load config from file", "error")
 
@@ -169,6 +243,23 @@ class ConfigManager:
                 if key == 'QASE_DEBUG':
                     self.config.set_debug(value)
 
+                if key == 'QASE_EXCLUDE_PARAMS':
+                    self.config.set_exclude_params(
+                        [param.strip() for param in value.split(',')])
+
+                if key == 'QASE_STATUS_MAPPING':
+                    # Parse status mapping from environment variable
+                    # Format: "source1=target1,source2=target2"
+                    if value:
+                        mapping_dict = {}
+                        pairs = value.split(',')
+                        for pair in pairs:
+                            pair = pair.strip()
+                            if pair and '=' in pair:
+                                source_status, target_status = pair.split('=', 1)
+                                mapping_dict[source_status.strip()] = target_status.strip()
+                        self.config.set_status_mapping(mapping_dict)
+
                 if key == 'QASE_EXECUTION_PLAN_PATH':
                     self.config.execution_plan.set_path(value)
 
@@ -199,9 +290,45 @@ class ConfigManager:
                 if key == 'QASE_TESTOPS_RUN_COMPLETE':
                     self.config.testops.run.set_complete(value)
 
+                if key == 'QASE_TESTOPS_RUN_TAGS':
+                    self.config.testops.run.set_tags(
+                        [tag.strip() for tag in value.split(',')])
+
+                if key == 'QASE_TESTOPS_RUN_EXTERNAL_LINK_TYPE':
+                    if not self.config.testops.run.external_link:
+                        from .models.external_link import ExternalLinkConfig
+                        self.config.testops.run.external_link = ExternalLinkConfig()
+                    self.config.testops.run.external_link.set_type(value)
+
+                if key == 'QASE_TESTOPS_RUN_EXTERNAL_LINK_URL':
+                    if not self.config.testops.run.external_link:
+                        from .models.external_link import ExternalLinkConfig
+                        self.config.testops.run.external_link = ExternalLinkConfig()
+                    self.config.testops.run.external_link.set_link(value)
+
                 if key == 'QASE_TESTOPS_BATCH_SIZE':
                     self.config.testops.batch.set_size(value)
 
+                if key == 'QASE_TESTOPS_CONFIGURATIONS_VALUES':
+                    # Parse configurations from environment variable
+                    # Format: "group1=value1,group2=value2"
+                    if value:
+                        config_pairs = value.split(',')
+                        for pair in config_pairs:
+                            if '=' in pair:
+                                name, config_value = pair.split('=', 1)
+                                self.config.testops.configurations.add_value(name.strip(), config_value.strip())
+
+                if key == 'QASE_TESTOPS_CONFIGURATIONS_CREATE_IF_NOT_EXISTS':
+                    self.config.testops.configurations.set_create_if_not_exists(value)
+
+                if key == 'QASE_TESTOPS_STATUS_FILTER':
+                    # Parse comma-separated string
+                    self.config.testops.set_status_filter([s.strip() for s in value.split(',')])
+
+                if key == 'QASE_TESTOPS_SHOW_PUBLIC_REPORT_LINK':
+                    self.config.testops.set_show_public_report_link(value)
+
                 if key == 'QASE_REPORT_DRIVER':
                     self.config.report.set_driver(value)
 
@@ -214,5 +341,17 @@ class ConfigManager:
                 if key == 'QASE_PYTEST_CAPTURE_LOGS':
                     self.config.framework.pytest.set_capture_logs(value)
 
+                if key == 'QASE_PYTEST_XFAIL_STATUS_XFAIL':
+                    self.config.framework.pytest.xfail_status.set_xfail(value)
+
+                if key == 'QASE_PYTEST_XFAIL_STATUS_XPASS':
+                    self.config.framework.pytest.xfail_status.set_xpass(value)
+
+                if key == 'QASE_LOGGING_CONSOLE':
+                    self.config.logging.set_console(QaseUtils.parse_bool(value))
+
+                if key == 'QASE_LOGGING_FILE':
+                    self.config.logging.set_file(QaseUtils.parse_bool(value))
+
         except Exception as e:
-            self.logger.log("Failed to load config from env vars {e}", "error")
+            self.logger.log(f"Failed to load config from env vars {e}", "error")

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

@@ -1,19 +1,80 @@
+from enum import Enum
+from typing import Type, Union
+
 from ..basemodel import BaseModel
 from ... import QaseUtils
 
 
+class Video(Enum):
+    off = "off"
+    on = "on"
+    failed = "retain-on-failure"
+
+
+class Trace(Enum):
+    off = "off"
+    on = "on"
+    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)
 
 
+class PlaywrightConfig(BaseModel):
+    output_dir: str = None
+    video: Video = None
+    trace: Trace = None
+
+    def __init__(self):
+        self.output_dir = "test-results"
+        self.video = Video.off
+        self.trace = Trace.off
+
+    def set_output_dir(self, output_dir: str):
+        self.output_dir = output_dir
+
+    def set_video(self, value: str):
+        self.video = self.__set_mode(Video, value)
+
+    def set_trace(self, value: str):
+        self.trace = self.__set_mode(Trace, value)
+
+    @staticmethod
+    def __set_mode(enum_class: Type[Union[Video, Trace]], value: str):
+        for mode in enum_class:
+            if mode.value == value:
+                return mode
+        return None
+
+
 class Framework(BaseModel):
     pytest: PytestConfig = None
+    playwright: PlaywrightConfig = None
 
     def __init__(self):
         self.pytest = PytestConfig()
+        self.playwright = PlaywrightConfig()

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'])