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

qase/commons/client/api_v2_client.py

@@ -1,7 +1,7 @@
-from typing import Dict
+from typing import Dict, Union, Optional
 
 import certifi
-from qase.api_client_v2 import ResultsApi
+from qase.api_client_v2 import ResultsApi, ResultCreateFields
 from qase.api_client_v2.api_client import ApiClient
 from qase.api_client_v2.configuration import Configuration
 from qase.api_client_v2.models.create_results_request_v2 import CreateResultsRequestV2
@@ -16,14 +16,20 @@ from qase.api_client_v2.models.result_steps_type import ResultStepsType
 from .api_v1_client import ApiV1Client
 from .. import Logger
 from ..exceptions.reporter import ReporterException
+from ..models.config.framework import Video, Trace
 from ..models import Attachment, Result
 from ..models.config.qaseconfig import QaseConfig
 from ..models.step import StepType, Step
+from ..util.host_data import HostData
 
 
 class ApiV2Client(ApiV1Client):
-    def __init__(self, config: QaseConfig, logger: Logger):
+    def __init__(self, config: QaseConfig, logger: Logger, host_data: Optional[HostData] = None,
+                 framework: Union[str, None] = None, reporter_name: Union[str, None] = None):
         ApiV1Client.__init__(self, config, logger)
+        self.host_data = host_data or {}
+        self.framework = framework
+        self.reporter_name = reporter_name
 
         try:
             self.logger.log_debug("Preparing API V2 client")
@@ -39,10 +45,84 @@ class ApiV2Client(ApiV1Client):
                 self.web = f'https://{host}'
 
             self.client_v2 = ApiClient(configuration)
+            
+            # Add X-Client and X-Platform headers
+            self._add_client_headers()
+            
             self.logger.log_debug("API V2 client prepared")
         except Exception as e:
             self.logger.log(f"Error at preparing API V2 client: {e}", "error")
             raise ReporterException(e)
+    
+    def _add_client_headers(self):
+        """Add X-Client and X-Platform headers to API client"""
+        try:
+            # Use host_data passed from Core reporter
+            host_data = self.host_data
+            
+            # Use framework and reporter_name for names in X-Client header
+            framework = self.framework
+            reporter_name = self.reporter_name
+            
+            # Build X-Client header
+            # Format: reporter=qase-pytest;reporter_version=v1.0.0;framework=pytest;framework_version=7.0.0;client_version_v1=v1.0.0;client_version_v2=v2.0.0;core_version=v1.5.0
+            x_client_parts = []
+            
+            if reporter_name:
+                x_client_parts.append(f"reporter={reporter_name}")
+                reporter_version = host_data.get('reporter', '')
+                if reporter_version:
+                    x_client_parts.append(f"reporter_version={reporter_version}")
+            
+            if framework:
+                x_client_parts.append(f"framework={framework}")
+                framework_version = host_data.get('framework', '')
+                if framework_version:
+                    x_client_parts.append(f"framework_version={framework_version}")
+            
+            client_v1_version = host_data.get('apiClientV1', '')
+            if client_v1_version:
+                x_client_parts.append(f"client_version_v1={client_v1_version}")
+            
+            client_v2_version = host_data.get('apiClientV2', '')
+            if client_v2_version:
+                x_client_parts.append(f"client_version_v2={client_v2_version}")
+            
+            core_version = host_data.get('commons', '')
+            if core_version:
+                x_client_parts.append(f"core_version={core_version}")
+            
+            x_client = ";".join(x_client_parts)
+            
+            # Build X-Platform header
+            # Format: os=Linux;arch=aarch64;python=3.9.0;pip=22.0.0
+            x_platform_parts = []
+            
+            os_name = host_data.get('system', '')
+            if os_name:
+                x_platform_parts.append(f"os={os_name}")
+            
+            arch = host_data.get('arch', '')
+            if arch:
+                x_platform_parts.append(f"arch={arch}")
+            
+            python_version = host_data.get('python', '')
+            if python_version:
+                x_platform_parts.append(f"python={python_version}")
+            
+            pip_version = host_data.get('pip', '')
+            if pip_version:
+                x_platform_parts.append(f"pip={pip_version}")
+            
+            x_platform = ";".join(x_platform_parts)
+            
+            # Add headers to client
+            if x_client:
+                self.client_v2.default_headers['X-Client'] = x_client
+            if x_platform:
+                self.client_v2.default_headers['X-Platform'] = x_platform
+        except Exception as e:
+            self.logger.log(f"Error adding client headers: {e}", "error")
 
     def send_results(self, project_code: str, run_id: str, results: []) -> None:
         api_results = ResultsApi(self.client_v2)
@@ -55,8 +135,15 @@ class ApiV2Client(ApiV1Client):
     def _prepare_result(self, project_code: str, result: Result) -> ResultCreate:
         attached = []
         if result.attachments:
-            for attachment in result.attachments:
-                attached.extend(self._upload_attachment(project_code, attachment))
+            # Collect all attachments that should be uploaded
+            attachments_to_upload = [
+                attachment for attachment in result.attachments
+                if not self.__should_skip_attachment(attachment, result)
+            ]
+            if attachments_to_upload:
+                attach_id = self._upload_attachment(project_code, attachments_to_upload)
+                if attach_id:
+                    attached.extend(attach_id)
 
         steps = []
         for step in result.steps:
@@ -71,27 +158,29 @@ class ApiV2Client(ApiV1Client):
         result_model_v2 = ResultCreate(
             title=result.get_title(),
             signature=result.signature,
-            testops_id=result.get_testops_id(),
-            execution=ResultExecution(start_time=result.execution.start_time, end_time=result.execution.end_time,
-                                      status=result.execution.status, duration=result.execution.duration,
+            testops_ids=result.get_testops_ids(),
+            execution=ResultExecution(status=result.execution.status, duration=result.execution.duration,
+                                      start_time=result.execution.start_time, end_time=result.execution.end_time,
                                       stacktrace=result.execution.stacktrace, thread=result.execution.thread),
-            fields=result.fields,
+            fields=ResultCreateFields.from_dict(result.fields),
             attachments=[attach.hash for attach in attached],
             steps=steps,
-            step_type=ResultStepsType.CLASSIC,
-            params=result.params,
-            muted=False,
+            steps_type=ResultStepsType.CLASSIC,
+            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,
         )
 
-        if result.get_suite_title():
+        if result.relations is not None and result.relations.suite is not None and len(
+                result.relations.suite.data) != 0:
             data = []
             root_suite = self.config.root_suite
             if root_suite:
                 data.append(RelationSuiteItem(title=root_suite))
 
-            for suite in result.get_suite_title().split("."):
-                data.append(RelationSuiteItem(title=suite))
+            for raw in result.relations.suite.data:
+                data.append(RelationSuiteItem(title=raw.title))
 
             result_model_v2.relations = ResultRelations(suite=RelationSuite(data=data))
 
@@ -104,8 +193,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
+            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
@@ -116,31 +213,60 @@ class ApiV2Client(ApiV1Client):
                 prepared_step['data']['action'] = step.data.request_method + " " + step.data.request_url
 
                 if step.data.request_body:
-                    step.attachments.append(
+                    step.add_attachment(
                         Attachment(file_name='request_body.txt', content=step.data.request_body, mime_type='text/plain',
                                    temporary=True))
                 if step.data.request_headers:
-                    step.attachments.append(
+                    step.add_attachment(
                         Attachment(file_name='request_headers.txt', content=step.data.request_headers,
                                    mime_type='text/plain', temporary=True))
                 if step.data.response_body:
-                    step.attachments.append(Attachment(file_name='response_body.txt', content=step.data.response_body,
-                                                       mime_type='text/plain', temporary=True))
+                    step.add_attachment(Attachment(file_name='response_body.txt', content=step.data.response_body,
+                                                   mime_type='text/plain', temporary=True))
                 if step.data.response_headers:
-                    step.attachments.append(
+                    step.add_attachment(
                         Attachment(file_name='response_headers.txt', content=step.data.response_headers,
                                    mime_type='text/plain', temporary=True))
 
             if step.step_type == StepType.GHERKIN:
-                prepared_step['data']['action'] = step.data.keyword
+                action = step.data.keyword
+                if step.data.keyword != step.data.name:
+                    action += " " + step.data.name
+                prepared_step['data']['action'] = action
+                if step.data.data:
+                    prepared_step['data']['input_data'] = step.data.data
 
             if step.step_type == StepType.SLEEP:
                 prepared_step['data']['action'] = f"Sleep for {step.data.duration} seconds"
 
-            if step.attachments:
+            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.attachments:
-                    uploaded_attachments.extend(self._upload_attachment(project_code, file))
+                attach_id = self._upload_attachment(project_code, step.execution.attachments)
+                if attach_id:
+                    uploaded_attachments.extend(attach_id)
 
                 prepared_step['execution']['attachments'] = [attach.hash for attach in uploaded_attachments]
 
@@ -152,3 +278,14 @@ class ApiV2Client(ApiV1Client):
         except Exception as e:
             self.logger.log(f"Error at preparing step: {e}", "error")
             raise ReporterException(e)
+
+    def __should_skip_attachment(self, attachment, result):
+        if (self.config.framework.playwright.video == Video.failed and
+                result.execution.status != 'failed' and
+                attachment.file_name == 'video.webm'):
+            return True
+        if (self.config.framework.playwright.trace == Trace.failed and
+                result.execution.status != 'failed' and
+                attachment.file_name == 'trace.zip'):
+            return True
+        return False

qase/commons/client/base_api_client.py

@@ -1,7 +1,8 @@
 import abc
-from typing import Union
+from typing import Union, List
 
 from qase.api_client_v1 import Project, AttachmentGet
+from qase.api_client_v1.models.attachmentupload import Attachmentupload
 
 from ..models import Attachment
 
@@ -30,7 +31,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
 
@@ -41,13 +42,18 @@ class BaseApiClient(abc.ABC):
         pass
 
     @abc.abstractmethod
-    def _upload_attachment(self, project_code: str, attachment: Attachment) -> Union[AttachmentGet, None]:
+    def _upload_attachment(self, project_code: str, attachment: Union[Attachment, List[Attachment]]) -> List[Attachmentupload]:
         """
-        Upload an attachment to Qase TestOps
+        Upload one or multiple attachments to Qase TestOps with batching support.
+        
+        The method automatically groups attachments into batches respecting the following limits:
+        - Up to 32 MB per file
+        - Up to 128 MB per single request
+        - Up to 20 files per single request
 
         :param project_code: project code
-        :param attachment: attachment model
-        :return: attachment data or None if attachment not uploaded
+        :param attachment: single attachment or list of attachments
+        :return: list of uploaded attachment data
         """
         pass
 
@@ -86,3 +92,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,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)
 
@@ -185,10 +276,10 @@ class ConfigManager:
                     self.config.testops.set_defect(value)
 
                 if key == 'QASE_TESTOPS_PLAN_ID':
-                    self.config.testops.plan.set_id(value)
+                    self.config.testops.plan.set_id(int(value.strip()))
 
                 if key == 'QASE_TESTOPS_RUN_ID':
-                    self.config.testops.run.set_id(value)
+                    self.config.testops.run.set_id(int(value.strip()))
 
                 if key == 'QASE_TESTOPS_RUN_TITLE':
                     self.config.testops.run.set_title(value)
@@ -199,8 +290,44 @@ 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)
+                    self.config.testops.batch.set_size(int(value.strip()))
+
+                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")