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

qase/__init__.py

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

qase/commons/client/api_v1_client.py

@@ -1,16 +1,18 @@
-from typing import Dict, Union
+from datetime import datetime, timezone
+from typing import Union, List
 
 import certifi
 from qase.api_client_v1 import ApiClient, ProjectsApi, Project, EnvironmentsApi, RunsApi, AttachmentsApi, \
-    AttachmentGet, RunCreate, ResultsApi, ResultcreateBulk, AuthorsApi
+    AttachmentGet, RunCreate, ConfigurationsApi, ConfigurationCreate, ConfigurationGroupCreate, RunPublic
+from qase.api_client_v1.models.attachmentupload import Attachmentupload
 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):
@@ -66,7 +68,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
@@ -80,35 +149,158 @@ class ApiV1Client(BaseApiClient):
             self.logger.log(f"Error at completing run {run_id}: {e}", "error")
             raise ReporterException(e)
 
-    def _upload_attachment(self, project_code: str, attachment: Attachment) -> Union[AttachmentGet, None]:
-        try:
-            self.logger.log_debug(f"Uploading attachment {attachment.id} for project {project_code}")
-            attach_api = AttachmentsApi(self.client)
-            response = attach_api.upload_attachment(project_code, file=[attachment.get_for_upload()])
-
-            return response.result
-
-        except Exception as e:
-            self.logger.log(f"Error at uploading attachment: {e}", "debug")
-            return None
+    def _upload_attachment(self, project_code: str, attachment: Union[Attachment, List[Attachment]]) -> List[Attachmentupload]:
+        """
+        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: single attachment or list of attachments
+        :return: list of uploaded attachment data
+        """
+        # Normalize input to list
+        attachments = attachment if isinstance(attachment, list) else [attachment]
+        
+        if not attachments:
+            return []
+        
+        # Constants for upload limits
+        MAX_FILE_SIZE = 32 * 1024 * 1024  # 32 MB in bytes
+        MAX_REQUEST_SIZE = 128 * 1024 * 1024  # 128 MB in bytes
+        MAX_FILES_PER_REQUEST = 20
+        
+        # Prepare attachments with size information
+        attachments_with_size = []
+        for att in attachments:
+            try:
+                # Get file data to check size
+                file_tuple = att.get_for_upload()
+                file_data = file_tuple[1]  # Get file data (second element of tuple)
+                file_size = len(file_data)
+                
+                # Check individual file size limit
+                if file_size > MAX_FILE_SIZE:
+                    self.logger.log(
+                        f"Attachment {att.file_name} ({file_size / 1024 / 1024:.2f} MB) exceeds "
+                        f"maximum file size limit of 32 MB. Skipping.",
+                        "error"
+                    )
+                    continue
+                
+                attachments_with_size.append((att, file_size))
+            except Exception as e:
+                self.logger.log(f"Error preparing attachment {att.file_name}: {e}", "error")
+                continue
+        
+        if not attachments_with_size:
+            return []
+        
+        # Group attachments into batches
+        batches = []
+        current_batch = []
+        current_batch_size = 0
+        
+        for att, file_size in attachments_with_size:
+            # Check if adding this file would exceed limits
+            would_exceed_size = current_batch_size + file_size > MAX_REQUEST_SIZE
+            would_exceed_count = len(current_batch) >= MAX_FILES_PER_REQUEST
+            
+            if would_exceed_size or would_exceed_count:
+                # Start a new batch
+                if current_batch:
+                    batches.append(current_batch)
+                current_batch = [att]
+                current_batch_size = file_size
+            else:
+                # Add to current batch
+                current_batch.append(att)
+                current_batch_size += file_size
+        
+        # Add the last batch if it has items
+        if current_batch:
+            batches.append(current_batch)
+        
+        # Upload batches
+        all_uploaded = []
+        attach_api = AttachmentsApi(self.client)
+        
+        for batch_idx, batch in enumerate(batches, 1):
+            try:
+                self.logger.log_debug(
+                    f"Uploading batch {batch_idx}/{len(batches)} with {len(batch)} file(s) "
+                    f"for project {project_code}"
+                )
+                
+                # Prepare files for upload
+                files_for_upload = [att.get_for_upload() for att in batch]
+                
+                # Upload batch
+                response = attach_api.upload_attachment(project_code, file=files_for_upload)
+                
+                if response.result:
+                    all_uploaded.extend(response.result)
+                    self.logger.log_debug(
+                        f"Successfully uploaded batch {batch_idx}/{len(batches)}: "
+                        f"{len(response.result)} file(s)"
+                    )
+                else:
+                    self.logger.log(
+                        f"Batch {batch_idx}/{len(batches)} upload returned no results",
+                        "error"
+                    )
+                    
+            except Exception as e:
+                self.logger.log(
+                    f"Error uploading batch {batch_idx}/{len(batches)}: {e}",
+                    "error"
+                )
+                # Continue with next batch even if one fails
+                continue
+        
+        return all_uploaded
 
     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})
             )
 
-            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")
@@ -121,166 +313,65 @@ 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:
-                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:
-            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
-
-        if result.get_field('author'):
-            author_id = self._get_author_id(result.get_field('author'))
-            if author_id:
-                result_model["author_id"] = author_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
-
-            if step.step_type == StepType.SLEEP:
-                prepared_step['action'] = f"Sleep for {step.data.duration} seconds"
-
-            if step.attachments:
-                uploaded_attachments = []
-                for file in step.attachments:
-                    attach_id = self._upload_attachment(project_code, file)
-                    if attach_id:
-                        uploaded_attachments.extend(attach_id)
-                prepared_step['attachments'] = [attach.hash for attach in uploaded_attachments]
-
-            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
+            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 preparing step: {e}", "error")
-            raise ReporterException(e)
-
-    def _get_author_id(self, author: str) -> Union[str, None]:
-        if author in self.__authors:
-            return self.__authors[author]
-
-        author_api = AuthorsApi(self.client)
-        authors = author_api.get_authors(search=author)
-        if authors.result.total == 0:
+            self.logger.log(f"Error at enabling public report for run {run_id}: {e}", "error")
             return None
 
-        self.__authors[author] = authors.result.entities[0].author_id
-
-        return authors.result.entities[0].author_id
+    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
@@ -292,3 +383,6 @@ class ApiV1Client(BaseApiClient):
                 attachment.file_name == 'trace.zip'):
             return True
         return False
+
+    def send_results(self, project_code: str, run_id: str, results: []) -> None:
+        raise NotImplementedError("use ApiV2Client instead")