qase-python-commons 3.1.3__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

@@ -1,21 +1,24 @@
-from typing import Dict, Union
+from datetime import datetime, timezone
+from typing import Union
 
 import certifi
 from qase.api_client_v1 import ApiClient, ProjectsApi, Project, EnvironmentsApi, RunsApi, AttachmentsApi, \
-    AttachmentGet, RunCreate, ResultsApi, ResultcreateBulk
+    AttachmentGet, RunCreate, ConfigurationsApi, ConfigurationCreate, ConfigurationGroupCreate, RunPublic
 from qase.api_client_v1.configuration import Configuration
 from .. import Logger
 from .base_api_client import BaseApiClient
 from ..exceptions.reporter import ReporterException
-from ..models import Attachment, Result, Step
+from ..models import Attachment
+from ..models.config.framework import Video, Trace
 from ..models.config.qaseconfig import QaseConfig
-from ..models.step import StepType
+from ..models.config.testops import ConfigurationValue
 
 
 class ApiV1Client(BaseApiClient):
     def __init__(self, config: QaseConfig, logger: Logger):
         self.logger = logger
         self.config = config
+        self.__authors = {}
 
         try:
             self.logger.log_debug("Preparing API client")
@@ -64,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
@@ -73,7 +143,7 @@ class ApiV1Client(BaseApiClient):
             return
         try:
             api_runs.complete_run(project_code, run_id)
-            self.logger.log(f"Run {run_id} was completed successfully", "info")
+            self.logger.log(f"Test run link: {self.web}/run/{project_code}/dashboard/{run_id}", "info")
         except Exception as e:
             self.logger.log(f"Error at completing run {run_id}: {e}", "error")
             raise ReporterException(e)
@@ -88,27 +158,46 @@ class ApiV1Client(BaseApiClient):
 
         except Exception as e:
             self.logger.log(f"Error at uploading attachment: {e}", "error")
-            raise ReporterException(e)
+            return None
 
     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
+            is_autotest=True,
+            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})
             )
 
-            self.logger.log(f"Test run was created: {self.web}/run/{project_code}/dashboard/{result.result.id}", "info")
+            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 result.result.id
+            return run_id
 
         except Exception as e:
             self.logger.log(f"Error at creating test run: {e}", "error")
@@ -121,139 +210,76 @@ class ApiV1Client(BaseApiClient):
             return True
         return False
 
-    def send_results(self, project_code: str, run_id: str, results: []) -> None:
-        api_results = ResultsApi(self.client)
-        results_to_send = [self._prepare_result(project_code, result) for result in results]
-        self.logger.log_debug(f"Sending results for run {run_id}: {results_to_send}")
-        api_results.create_result_bulk(
-            code=project_code,
-            id=run_id,
-            resultcreate_bulk=ResultcreateBulk(
-                results=results_to_send
-            )
-        )
-        self.logger.log_debug(f"Results for run {run_id} sent successfully")
-
-    def _prepare_result(self, project_code: str, result: Result) -> Dict:
-        attached = []
-        if result.attachments:
-            for attachment in result.attachments:
-                attached.extend(self._upload_attachment(project_code, attachment))
-
-        steps = []
-        for step in result.steps:
-            prepared = self._prepare_step(project_code, step)
-            steps.append(prepared)
-
-        case_data = {
-            "title": result.get_title(),
-            "description": result.get_field('description'),
-            "preconditions": result.get_field('preconditions'),
-            "postconditions": result.get_field('postconditions'),
-        }
-
-        for key, param in result.params.items():
-            # Hack to match old TestOps API
-            if param == "":
-                result.params[key] = "empty"
-
-        if result.get_field('severity'):
-            case_data["severity"] = result.get_field('severity')
-
-        if result.get_field('priority'):
-            case_data["priority"] = result.get_field('priority')
-
-        if result.get_field('layer'):
-            case_data["layer"] = result.get_field('layer')
-
-        suite = None
-        if result.get_suite_title():
-            suite = "\t".join(result.get_suite_title().split("."))
-
-        if result.get_field('suite'):
-            suite = result.get_field('suite')
-
-        root_suite = self.config.root_suite
-        if root_suite:
-            suite = f"{root_suite}\t{suite}"
-
-        if suite:
-            case_data["suite_title"] = suite
-
-        result_model = {
-            "status": result.execution.status,
-            "stacktrace": result.execution.stacktrace,
-            "time_ms": result.execution.duration,
-            "comment": result.message,
-            "attachments": [attach.hash for attach in attached],
-            "steps": steps,
-            "param": result.params,
-            "param_groups": result.param_groups,
-            "defect": self.config.testops.defect,
-            "case": case_data
-        }
-
-        test_ops_id = result.get_testops_id()
-
-        if test_ops_id:
-            result_model["case_id"] = test_ops_id
-
-        self.logger.log_debug(f"Prepared result: {result_model}")
-
-        return result_model
-
-    def _prepare_step(self, project_code: str, step: Step) -> Dict:
-        prepared_children = []
-
+    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:
-            prepared_step = {"time": step.execution.duration, "status": step.execution.status}
-
-            if step.execution.status == 'untested':
-                prepared_step["status"] = 'passed'
-
-            if step.execution.status == 'skipped':
-                prepared_step["status"] = 'blocked'
-
-            if step.step_type == StepType.TEXT:
-                prepared_step['action'] = step.data.action
-                if step.data.expected_result:
-                    prepared_step['expected_result'] = step.data.expected_result
-
-            if step.step_type == StepType.REQUEST:
-                prepared_step['action'] = step.data.request_method + " " + step.data.request_url
-                if step.data.request_body:
-                    step.attachments.append(
-                        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(
-                        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))
-                if step.data.response_headers:
-                    step.attachments.append(
-                        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['action'] = step.data.keyword
+            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
 
-            if step.step_type == StepType.SLEEP:
-                prepared_step['action'] = f"Sleep for {step.data.duration} seconds"
+    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")
 
-            if step.attachments:
-                uploaded_attachments = []
-                for file in step.attachments:
-                    uploaded_attachments.extend(self._upload_attachment(project_code, file))
-                prepared_step['attachments'] = [attach.hash for attach in uploaded_attachments]
+    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
 
-            if step.steps:
-                for substep in step.steps:
-                    prepared_children.append(self._prepare_step(project_code, substep))
-                prepared_step["steps"] = prepared_children
-            return prepared_step
-        except Exception as e:
-            self.logger.log(f"Error at preparing step: {e}", "error")
-            raise ReporterException(e)
+    def send_results(self, project_code: str, run_id: str, results: []) -> None:
+        raise NotImplementedError("use ApiV2Client instead")

qase/commons/client/api_v2_client.py

@@ -1,7 +1,7 @@
 from typing import Dict
 
 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,6 +16,7 @@ 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
@@ -56,7 +57,11 @@ class ApiV2Client(ApiV1Client):
         attached = []
         if result.attachments:
             for attachment in result.attachments:
-                attached.extend(self._upload_attachment(project_code, attachment))
+                if self.__should_skip_attachment(attachment, result):
+                    continue
+                attach_id = self._upload_attachment(project_code, attachment)
+                if attach_id:
+                    attached.extend(attach_id)
 
         steps = []
         for step in result.steps:
@@ -71,27 +76,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 +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
+            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 +131,59 @@ 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.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))
+                for file in step.execution.attachments:
+                    attach_id = self._upload_attachment(project_code, file)
+                    if attach_id:
+                        uploaded_attachments.extend(attach_id)
 
                 prepared_step['execution']['attachments'] = [attach.hash for attach in uploaded_attachments]
 
@@ -152,3 +195,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

@@ -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