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

qase/__init__.py

@@ -0,0 +1,3 @@
+"""
+Qase Python Commons package.
+"""

qase/commons/client/api_v1_client.py

@@ -3,7 +3,7 @@ from typing import Union
 
 import certifi
 from qase.api_client_v1 import ApiClient, ProjectsApi, Project, EnvironmentsApi, RunsApi, AttachmentsApi, \
-    AttachmentGet, RunCreate
+    AttachmentGet, RunCreate, ConfigurationsApi, ConfigurationCreate, ConfigurationGroupCreate, RunPublic
 from qase.api_client_v1.configuration import Configuration
 from .. import Logger
 from .base_api_client import BaseApiClient
@@ -11,6 +11,7 @@ from ..exceptions.reporter import ReporterException
 from ..models import Attachment
 from ..models.config.framework import Video, Trace
 from ..models.config.qaseconfig import QaseConfig
+from ..models.config.testops import ConfigurationValue
 
 
 class ApiV1Client(BaseApiClient):
@@ -66,7 +67,74 @@ class ApiV1Client(BaseApiClient):
             self.logger.log("Exception when calling EnvironmentsApi->get_environments: %s\n" % e, "error")
             raise ReporterException(e)
 
-    def complete_run(self, project_code: str, run_id: str) -> None:
+    def get_configurations(self, project_code: str):
+        """Get all configurations for the project"""
+        try:
+            self.logger.log_debug(f"Getting configurations for project {project_code}")
+            api_instance = ConfigurationsApi(self.client)
+            response = api_instance.get_configurations(code=project_code)
+            if hasattr(response, 'result') and hasattr(response.result, 'entities'):
+                return response.result.entities
+            return []
+        except Exception as e:
+            self.logger.log(f"Exception when calling ConfigurationsApi->get_configurations: {e}", "error")
+            return []
+
+    def find_or_create_configuration(self, project_code: str, config_value: ConfigurationValue) -> Union[int, None]:
+        """Find existing configuration or create new one if createIfNotExists is True"""
+        try:
+            configurations = self.get_configurations(project_code)
+            
+            # Search for existing configuration
+            for group in configurations:
+                if hasattr(group, 'configurations'):
+                    for config in group.configurations:
+                        # API returns configurations with 'title' field, not 'name' and 'value'
+                        # We need to match group.title with config_value.name and config.title with config_value.value
+                        config_title = config.title if hasattr(config, 'title') else 'No title'
+                        group_title = group.title if hasattr(group, 'title') else 'No title'
+                        
+                        if (group_title == config_value.name and config_title == config_value.value):
+                            return config.id
+            
+            # Configuration not found
+            if not self.config.testops.configurations.create_if_not_exists:
+                return None
+            
+            # Create new configuration
+            # First, try to find existing group or create new one
+            group_id = None
+            for group in configurations:
+                if hasattr(group, 'title') and group.title == config_value.name:
+                    group_id = group.id
+                    break
+            
+            if group_id is None:
+                # Create new group
+                group_create = ConfigurationGroupCreate(title=config_value.name)
+                group_response = ConfigurationsApi(self.client).create_configuration_group(
+                    code=project_code, 
+                    configuration_group_create=group_create
+                )
+                group_id = group_response.result.id
+            
+            # Create configuration in the group
+            config_create = ConfigurationCreate(
+                title=config_value.value,
+                group_id=group_id
+            )
+            config_response = ConfigurationsApi(self.client).create_configuration(
+                code=project_code,
+                configuration_create=config_create
+            )
+            config_id = config_response.result.id
+            return config_id
+            
+        except Exception as e:
+            self.logger.log(f"Error at finding/creating configuration {config_value.name}={config_value.value}: {e}", "error")
+            return None
+
+    def complete_run(self, project_code: str, run_id: int) -> None:
         api_runs = RunsApi(self.client)
         self.logger.log_debug(f"Completing run {run_id}")
         res = api_runs.get_run(project_code, run_id).result
@@ -94,22 +162,42 @@ class ApiV1Client(BaseApiClient):
 
     def create_test_run(self, project_code: str, title: str, description: str, plan_id=None,
                         environment_id=None) -> str:
+        # Process configurations
+        configuration_ids = []
+        
+        if self.config.testops.configurations and self.config.testops.configurations.values:
+            for config_value in self.config.testops.configurations.values:
+                config_id = self.find_or_create_configuration(project_code, config_value)
+                if config_id:
+                    configuration_ids.append(config_id)
+        
         kwargs = dict(
             title=title,
             description=description,
             environment_id=(int(environment_id) if environment_id else None),
             plan_id=(int(plan_id) if plan_id else plan_id),
             is_autotest=True,
-            start_time=datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S")
+            start_time=datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S"),
+            tags=self.config.testops.run.tags
         )
-        self.logger.log_debug(f"Creating test run with parameters: {kwargs}")
+        
+        # Add configurations if any found
+        if configuration_ids:
+            kwargs['configurations'] = configuration_ids
+        
         try:
             result = RunsApi(self.client).create_run(
                 code=project_code,
                 run_create=RunCreate(**{k: v for k, v in kwargs.items() if v is not None})
             )
 
-            return result.result.id
+            run_id = result.result.id
+            
+            # Update external link if configured
+            if self.config.testops.run.external_link and run_id:
+                self.update_external_link(project_code, run_id)
+
+            return run_id
 
         except Exception as e:
             self.logger.log(f"Error at creating test run: {e}", "error")
@@ -122,6 +210,66 @@ class ApiV1Client(BaseApiClient):
             return True
         return False
 
+    def enable_public_report(self, project_code: str, run_id: int) -> str:
+        """
+        Enable public report for a test run and return the public link
+        
+        :param project_code: project code
+        :param run_id: test run id
+        :return: public report link or None if failed
+        """
+        try:
+            self.logger.log_debug(f"Enabling public report for run {run_id}")
+            api_runs = RunsApi(self.client)
+            
+            # Create RunPublic object with status=True
+            run_public = RunPublic(status=True)
+            
+            # Call the API to enable public report
+            response = api_runs.update_run_publicity(project_code, run_id, run_public)
+            
+            # Extract the public URL from response
+            if response.result and response.result.url:
+                public_url = response.result.url
+                self.logger.log_debug(f"Public report enabled for run {run_id}: {public_url}")
+                return public_url
+            else:
+                self.logger.log_debug(f"Public report enabled for run {run_id} but no URL returned")
+                return None
+                
+        except Exception as e:
+            self.logger.log(f"Error at enabling public report for run {run_id}: {e}", "error")
+            return None
+
+    def update_external_link(self, project_code: str, run_id: int):
+        """Update external link for a test run"""
+        try:
+            from qase.api_client_v1.models.runexternal_issues import RunexternalIssues
+            from qase.api_client_v1.models.runexternal_issues_links_inner import RunexternalIssuesLinksInner
+            
+            external_link = self.config.testops.run.external_link
+            api_type = external_link.to_api_type()
+            
+            run_external_issues = RunexternalIssues(
+                type=api_type,
+                links=[
+                    RunexternalIssuesLinksInner(
+                        run_id=run_id,
+                        external_issue=external_link.link
+                    )
+                ]
+            )
+            
+            RunsApi(self.client).run_update_external_issue(
+                code=project_code,
+                runexternal_issues=run_external_issues
+            )
+            
+            self.logger.log(f"External link updated for run {run_id}: {external_link.link}", "debug")
+            
+        except Exception as e:
+            self.logger.log(f"Error at updating external link: {e}", "error")
+
     def __should_skip_attachment(self, attachment, result):
         if (self.config.framework.playwright.video == Video.failed and
                 result.execution.status != 'failed' and

qase/commons/client/api_v2_client.py

@@ -84,7 +84,7 @@ class ApiV2Client(ApiV1Client):
             attachments=[attach.hash for attach in attached],
             steps=steps,
             steps_type=ResultStepsType.CLASSIC,
-            params=result.params,
+            params=result.params if not self.config.exclude_params else {key: value for key, value in result.params.items() if key not in self.config.exclude_params},
             param_groups=result.param_groups,
             message=result.message,
             defect=self.config.testops.defect,
@@ -111,10 +111,16 @@ class ApiV2Client(ApiV1Client):
 
         try:
             prepared_step = {'execution': {}, 'data': {}, 'steps': []}
-            prepared_step['execution']['status'] = ResultStepStatus(step.execution.status)
-            prepared_step['execution']['duration'] = step.execution.duration
-            prepared_step['execution']['start_time'] = step.execution.start_time
-            prepared_step['execution']['end_time'] = step.execution.end_time
+            if step.execution.status == 'untested':
+                prepared_step['execution']['status'] = ResultStepStatus('skipped')
+                prepared_step['execution']['duration'] = 0
+                prepared_step['execution']['start_time'] = None
+                prepared_step['execution']['end_time'] = None
+            else:
+                prepared_step['execution']['status'] = ResultStepStatus(step.execution.status)
+                prepared_step['execution']['duration'] = step.execution.duration
+                prepared_step['execution']['start_time'] = step.execution.start_time
+                prepared_step['execution']['end_time'] = step.execution.end_time
 
             if step.step_type == StepType.TEXT:
                 prepared_step['data']['action'] = step.data.action
@@ -149,6 +155,29 @@ class ApiV2Client(ApiV1Client):
             if step.step_type == StepType.SLEEP:
                 prepared_step['data']['action'] = f"Sleep for {step.data.duration} seconds"
 
+            if step.step_type == StepType.DB_QUERY:
+                # Format database query as action
+                action_parts = []
+                if step.data.database_type:
+                    action_parts.append(f"[{step.data.database_type}]")
+                action_parts.append(step.data.query)
+                prepared_step['data']['action'] = " ".join(action_parts)
+                
+                # Add expected_result if available
+                if step.data.expected_result:
+                    prepared_step['data']['expected_result'] = step.data.expected_result
+                
+                # Add connection info and execution time as input_data
+                info_parts = []
+                if step.data.connection_info:
+                    info_parts.append(f"Connection: {step.data.connection_info}")
+                if step.data.execution_time is not None:
+                    info_parts.append(f"Execution time: {step.data.execution_time:.3f}s")
+                if step.data.rows_affected is not None:
+                    info_parts.append(f"Rows affected: {step.data.rows_affected}")
+                if info_parts:
+                    prepared_step['data']['input_data'] = " | ".join(info_parts)
+
             if step.execution.attachments:
                 uploaded_attachments = []
                 for file in step.execution.attachments:

qase/commons/client/base_api_client.py

@@ -30,7 +30,7 @@ class BaseApiClient(abc.ABC):
         pass
 
     @abc.abstractmethod
-    def complete_run(self, project_code: str, run_id: str) -> None:
+    def complete_run(self, project_code: str, run_id: int) -> None:
         """
         Complete a test run in Qase TestOps
 
@@ -86,3 +86,14 @@ class BaseApiClient(abc.ABC):
         :return: None
         """
         pass
+
+    @abc.abstractmethod
+    def enable_public_report(self, project_code: str, run_id: int) -> str:
+        """
+        Enable public report for a test run and return the public link
+        
+        :param project_code: project code
+        :param run_id: test run id
+        :return: public report link or None if failed
+        """
+        pass

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,15 +91,18 @@ 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")
                             )
@@ -96,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")
@@ -122,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(
@@ -135,7 +198,7 @@ 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")
                                 )
@@ -153,6 +216,9 @@ class ConfigManager:
                                         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")
 
@@ -177,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)
 
@@ -207,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)
 
@@ -228,6 +347,11 @@ class ConfigManager:
                 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,14 +1,39 @@
 import os
 import datetime
 import threading
+from typing import Optional
+
+
+class LoggingOptions:
+    def __init__(self, console: bool = True, file: bool = False):
+        self.console = console
+        self.file = file
 
 
 class Logger:
     _log_file = None
 
-    def __init__(self, debug: bool = False, prefix: str = '', dir: str = os.path.join('.', 'logs')) -> 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:
+        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'
@@ -21,16 +46,38 @@ class Logger:
 
             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"
 
-        try:
-            print(log, end='')
-        except (OSError, IOError):
-            pass
+        # Console output
+        if self.logging_options.console:
+            try:
+                print(log, end='')
+            except (OSError, IOError):
+                pass
 
-        if self.debug:
+        # File output
+        if self.logging_options.file:
             with self.lock:
                 with open(Logger._log_file, 'a', encoding='utf-8') as f:
                     f.write(log)
@@ -39,6 +86,15 @@ class Logger:
         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"):
         now = datetime.datetime.now()