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

qase/commons/reporters/core.py

@@ -1,5 +1,3 @@
-import os
-import json
 import time
 
 from ..config import ConfigManager
@@ -12,6 +10,9 @@ from ..models import Result, Attachment, Runtime
 from ..models.config.qaseconfig import Mode
 from typing import Union, List
 
+from ..util import get_host_info
+from ..status_mapping.status_mapping import StatusMapping
+
 """
     CoreReporter is a facade for all reporters and it is used to initialize and manage them.
     It is also used to pass configuration and logger to reporters, handle fallback logic and error handling.
@@ -19,26 +20,45 @@ from typing import Union, List
 
 
 class QaseCoreReporter:
-    def __init__(self, config: ConfigManager):
+    def __init__(self, config: ConfigManager, framework: Union[str, None] = None,
+                 reporter_name: Union[str, None] = None):
         config.validate_config()
         self.config = config.config
-        self.logger = Logger(self.config.debug)
+        # Use the logger from ConfigManager instead of creating a new one
+        self.logger = config.logger
         self._execution_plan = None
         self.profilers = []
         self.overhead = 0
 
+        # Initialize status mapping
+        self.status_mapping = StatusMapping.from_dict(self.config.status_mapping)
+        if not self.status_mapping.is_empty():
+            self.logger.log_debug(f"Status mapping initialized: {self.status_mapping}")
+
         # self._selective_execution_setup()
         self.fallback = self._fallback_setup()
 
         self.logger.log_debug(f"Config: {self.config}")
 
+        host_data = get_host_info(framework, reporter_name)
+        self.logger.log_debug(f"Host data: {host_data}")
+
+        # Store framework and reporter_name for passing to reporters
+        self.framework = framework
+        self.reporter_name = reporter_name
+        self.host_data = host_data
+
         # Reading reporter mode from config file
         mode = self.config.mode
 
         if mode == Mode.testops:
             try:
                 self._load_testops_plan()
-                self.reporter = QaseTestOps(config=self.config, logger=self.logger)
+                # Create API client with host_data for headers
+                from ..client.api_v2_client import ApiV2Client
+                api_client = ApiV2Client(self.config, self.logger, host_data=host_data, 
+                                       framework=framework, reporter_name=reporter_name)
+                self.reporter = QaseTestOps(config=self.config, logger=self.logger, client=api_client)
             except Exception as e:
                 self.logger.log('Failed to initialize TestOps reporter. Using fallback.', 'info')
                 self.logger.log(e, 'error')
@@ -61,14 +81,15 @@ class QaseCoreReporter:
                 self.logger.log('Failed to start run, disabling reporting', 'info')
                 self.logger.log(e, 'error')
                 self.reporter = None
+                return None
+
+        return None
 
     def complete_run(self) -> None:
         if self.reporter:
             try:
                 ts = time.time()
-                self.logger.log_debug("Completing run")
                 self.reporter.complete_run()
-                self.logger.log_debug("Run completed")
                 self.overhead += time.time() - ts
                 self.logger.log(f"Overhead for Qase Report: {round(self.overhead * 1000)}ms", 'info')
             except Exception as e:
@@ -81,7 +102,12 @@ class QaseCoreReporter:
             try:
                 ts = time.time()
                 self.logger.log_debug(f"Adding result {result}")
+
+                # Apply status mapping before adding result
+                self._apply_status_mapping(result)
+
                 self.reporter.add_result(result)
+
                 self.logger.log_debug(f"Result {result.get_title()} added")
                 self.overhead += time.time() - ts
             except Exception as e:
@@ -118,8 +144,9 @@ class QaseCoreReporter:
                 from ..profilers import SleepProfiler
                 self.profilers.append(SleepProfiler(runtime=runtime))
             if profiler == "db":
-                from ..profilers import DbProfiler
-                self.profilers.append(DbProfiler(runtime=runtime))
+                from ..profilers import DatabaseProfilerSingleton
+                DatabaseProfilerSingleton.init(runtime=runtime)
+                self.profilers.append(DatabaseProfilerSingleton.get_instance())
 
     def enable_profilers(self) -> None:
         if self.reporter:
@@ -180,7 +207,7 @@ class QaseCoreReporter:
                     host=self.config.testops.api.host
                 )
                 self._execution_plan = loader.load(self.config.testops.project,
-                                                  int(self.config.testops.plan.id))
+                                                   int(self.config.testops.plan.id))
         except Exception as e:
             self.logger.log('Failed to load test plan from Qase TestOps', 'info')
             self.logger.log(e, 'error')
@@ -201,3 +228,26 @@ class QaseCoreReporter:
         if self.config.fallback == Mode.report:
             return QaseReport(config=self.config, logger=self.logger)
         return None
+
+    def _apply_status_mapping(self, result: Result) -> None:
+        """
+        Apply status mapping to a test result.
+        
+        This method applies the configured status mapping to the result's execution status.
+        The mapping is applied before the result is sent to the reporter.
+        
+        Args:
+            result: Test result to apply status mapping to
+        """
+        if self.status_mapping.is_empty():
+            return
+        
+        original_status = result.get_status()
+        if not original_status:
+            return
+        
+        mapped_status = self.status_mapping.apply_mapping(original_status)
+        
+        if mapped_status != original_status:
+            result.execution.set_status(mapped_status)
+            self.logger.log_debug(f"Status mapped for '{result.get_title()}': {original_status} -> {mapped_status}")

qase/commons/reporters/report.py

@@ -31,17 +31,16 @@ class QaseReport:
 
     def start_run(self):
         self._check_report_path()
-        self.start_time = str(time.time())
+        self.start_time = str(QaseUtils.get_real_time())
 
     def complete_run(self):
-        self.end_time = str(time.time())
+        self.end_time = str(QaseUtils.get_real_time())
         self._compile_report()
 
     def complete_worker(self):
         pass
 
     def add_result(self, result: Result):
-        result.set_run_id(self.run_id)
         for attachment in result.attachments:
             self._persist_attachment(attachment)
 
@@ -68,18 +67,24 @@ class QaseReport:
                 mode = "w"
             if isinstance(attachment.content, bytes):
                 mode = "wb"
-            with open(f"{self.report_path}/attachments/{attachment.id}-{attachment.file_name}", mode) as f:
+
+            file_path = f"{self.report_path}/attachments/{attachment.id}-{attachment.file_name}"
+            with open(file_path, mode) as f:
                 f.write(attachment.content)
             # Clear content to save memory and avoid double writing
             attachment.content = None
+            attachment.file_path = file_path
+
         elif attachment.file_path:
+            file_path = f"{self.report_path}/attachments/{attachment.id}-{attachment.file_name}"
             shutil.copy2(os.path.abspath(attachment.file_path),
                          f"{self.report_path}/attachments/{attachment.id}-{attachment.file_name}")
+            attachment.file_path = file_path
 
     def _persist_attachments_in_steps(self, steps: list):
         for step in steps:
-            if step.attachments:
-                for attachment in step.attachments:
+            if step.execution.attachments:
+                for attachment in step.execution.attachments:
                     self._persist_attachment(attachment)
                 if step.steps:
                     self._persist_attachments_in_steps(step.steps)

qase/commons/reporters/testops.py

@@ -2,9 +2,8 @@ import threading
 import urllib.parse
 
 from datetime import datetime
-from typing import List
+from typing import List, Union
 from .. import Logger, ReporterException
-from ..client.api_v1_client import ApiV1Client
 from ..client.base_api_client import BaseApiClient
 from ..models import Result
 from ..models.config.qaseconfig import QaseConfig
@@ -15,12 +14,11 @@ DEFAULT_THREAD_COUNT = 4
 
 class QaseTestOps:
 
-    def __init__(self, config: QaseConfig, logger: Logger) -> None:
+    def __init__(self, config: QaseConfig, logger: Logger, client: BaseApiClient) -> None:
         self.config = config
         self.logger = logger
         self.__baseUrl = self.__get_host(config.testops.api.host)
-
-        self.client = self._prepare_client()
+        self.client = client
 
         run_id = self.config.testops.run.id
         plan_id = self.config.testops.plan.id
@@ -68,12 +66,6 @@ class QaseTestOps:
         """Verify that project exists in TestOps"""
         self.client.get_project(self.project_code)
 
-    def _prepare_client(self) -> BaseApiClient:
-        if self.config.testops.use_v2:
-            from ..client.api_v2_client import ApiV2Client
-            return ApiV2Client(self.config, self.logger)
-        return ApiV1Client(self.config, self.logger)
-
     def _send_results_threaded(self, results):
         try:
             self.client.send_results(self.project_code, self.run_id, results)
@@ -89,15 +81,34 @@ class QaseTestOps:
 
     def _send_results(self) -> None:
         if self.results:
-            # Acquire semaphore before starting the send operation
-            self.send_semaphore.acquire()
-            self.count_running_threads += 1
+            # Filter results by status if status_filter is configured
             results_to_send = self.results.copy()
+            
+            if self.config.testops.status_filter and len(self.config.testops.status_filter) > 0:
+                filtered_results = []
+                for result in results_to_send:
+                    result_status = result.get_status()
+                    if result_status and result_status not in self.config.testops.status_filter:
+                        filtered_results.append(result)
+                    else:
+                        self.logger.log_debug(f"Filtering out result '{result.title}' with status '{result_status}'")
+                
+                results_to_send = filtered_results
+                self.logger.log_debug(f"Filtered {len(self.results) - len(results_to_send)} results by status filter")
+            
+            if results_to_send:
+                # Acquire semaphore before starting the send operation
+                self.send_semaphore.acquire()
+                self.count_running_threads += 1
+
+                # Start a new thread for sending results
+                send_thread = threading.Thread(target=self._send_results_threaded, args=(results_to_send,))
+                send_thread.start()
+            else:
+                self.logger.log("No results to send after filtering", "info")
+            
+            # Clear results regardless of filtering
             self.results = []
-
-            # Start a new thread for sending results
-            send_thread = threading.Thread(target=self._send_results_threaded, args=(results_to_send,))
-            send_thread.start()
         else:
             self.logger.log("No results to send", "info")
 
@@ -120,18 +131,37 @@ class QaseTestOps:
     def complete_run(self) -> None:
         if len(self.results) > 0:
             self._send_results()
+
+        while self.count_running_threads > 0:
+                pass    
+        
         if self.complete_after_run:
-            while self.count_running_threads > 0:
-                pass
+            self.logger.log_debug("Completing run")
             self.client.complete_run(self.project_code, self.run_id)
+            self.logger.log_debug("Run completed")
+            
+            # Enable public report if configured
+            if self.config.testops.show_public_report_link:
+                try:
+                    self.logger.log_debug("Enabling public report")
+                    public_url = self.client.enable_public_report(self.project_code, self.run_id)
+                    if public_url:
+                        self.logger.log(f"Public report link: {public_url}", "info")
+                    else:
+                        self.logger.log("Failed to generate public report link", "warning")
+                except Exception as e:
+                    self.logger.log(f"Failed to generate public report link: {e}", "warning")
 
     def complete_worker(self) -> None:
         if len(self.results) > 0:
             self._send_results()
+        while self.count_running_threads > 0:
+            pass
+        self.logger.log_debug("Worker completed")
 
     def add_result(self, result: Result) -> None:
         if result.get_status() == 'failed':
-            self.__show_link(result.testops_id, result.title)
+            self.__show_link(result.testops_ids, result.title)
         self.results.append(result)
         if len(self.results) >= self.batch_size:
             self._send_results()
@@ -142,15 +172,14 @@ class QaseTestOps:
     def set_results(self, results) -> None:
         self.results = results
 
-    def __show_link(self, id, title: str):
-        link = self.__prepare_link(id, title)
+    def __show_link(self, ids: Union[None, List[int]], title: str):
+        link = self.__prepare_link(ids, title)
         self.logger.log(f"See why this test failed: {link}", "info")
 
-    def __prepare_link(self, id, title: str):
+    def __prepare_link(self, ids: Union[None, List[int]], title: str):
         link = f"{self.__baseUrl}/run/{self.project_code}/dashboard/{self.run_id}?source=logs&status=%5B2%5D&search="
-        if id:
-            return f"{link}{id}`"
-
+        if ids is not None and len(ids) > 0:
+            return f"{link}{self.project_code}-{ids[0]}"
         return f"{link}{urllib.parse.quote_plus(title)}"
 
     @staticmethod

qase/commons/status_mapping/__init__.py

@@ -0,0 +1,12 @@
+"""
+Utilities package for Qase Python Commons.
+"""
+
+from .status_mapping import StatusMapping, StatusMappingError, create_status_mapping_from_config, create_status_mapping_from_env
+
+__all__ = [
+    'StatusMapping',
+    'StatusMappingError', 
+    'create_status_mapping_from_config',
+    'create_status_mapping_from_env'
+]

qase/commons/status_mapping/status_mapping.py

@@ -0,0 +1,237 @@
+"""
+Status mapping utilities for Qase Python Commons.
+
+This module provides functionality to map test result statuses from one value to another
+based on configuration. This is useful for standardizing status values across different
+testing frameworks or for custom status transformations.
+"""
+
+from typing import Dict, Optional, List
+import os
+import logging
+
+
+class StatusMappingError(Exception):
+    """Exception raised when status mapping encounters an error."""
+    pass
+
+
+class StatusMapping:
+    """
+    Handles mapping of test result statuses.
+    
+    This class provides functionality to:
+    - Parse status mapping from configuration
+    - Validate status mappings
+    - Apply status mappings to test results
+    - Support both JSON configuration and environment variables
+    """
+    
+    # Valid statuses that can be mapped
+    VALID_STATUSES = {
+        'passed', 'failed', 'skipped', 'disabled', 'blocked', 'invalid'
+    }
+    
+    def __init__(self, mapping: Optional[Dict[str, str]] = None):
+        """
+        Initialize StatusMapping with optional mapping dictionary.
+        
+        Args:
+            mapping: Dictionary mapping source status to target status
+        """
+        self.mapping = mapping or {}
+        self.logger = logging.getLogger(__name__)
+    
+    @classmethod
+    def from_dict(cls, mapping_dict: Dict[str, str]) -> 'StatusMapping':
+        """
+        Create StatusMapping from dictionary.
+        
+        Args:
+            mapping_dict: Dictionary with status mappings
+            
+        Returns:
+            StatusMapping instance
+            
+        Raises:
+            StatusMappingError: If mapping contains invalid statuses
+        """
+        instance = cls()
+        instance.set_mapping(mapping_dict)
+        return instance
+    
+    @classmethod
+    def from_env_string(cls, env_string: str) -> 'StatusMapping':
+        """
+        Create StatusMapping from environment variable string.
+        
+        Expected format: "source1=target1,source2=target2"
+        
+        Args:
+            env_string: Environment variable string
+            
+        Returns:
+            StatusMapping instance
+            
+        Raises:
+            StatusMappingError: If string format is invalid
+        """
+        instance = cls()
+        instance.parse_env_string(env_string)
+        return instance
+    
+    def set_mapping(self, mapping_dict: Dict[str, str]) -> None:
+        """
+        Set status mapping from dictionary.
+        
+        Args:
+            mapping_dict: Dictionary with status mappings
+            
+        Raises:
+            StatusMappingError: If mapping contains invalid statuses
+        """
+        if not isinstance(mapping_dict, dict):
+            raise StatusMappingError("Mapping must be a dictionary")
+        
+        # Validate all statuses in the mapping
+        for source_status, target_status in mapping_dict.items():
+            if source_status not in self.VALID_STATUSES:
+                raise StatusMappingError(f"Invalid source status: {source_status}")
+            if target_status not in self.VALID_STATUSES:
+                raise StatusMappingError(f"Invalid target status: {target_status}")
+        
+        self.mapping = mapping_dict.copy()
+        self.logger.debug(f"Status mapping set: {self.mapping}")
+    
+    def parse_env_string(self, env_string: str) -> None:
+        """
+        Parse status mapping from environment variable string.
+        
+        Expected format: "source1=target1,source2=target2"
+        
+        Args:
+            env_string: Environment variable string
+            
+        Raises:
+            StatusMappingError: If string format is invalid
+        """
+        if not env_string or not env_string.strip():
+            self.mapping = {}
+            return
+        
+        mapping_dict = {}
+        pairs = env_string.split(',')
+        
+        for pair in pairs:
+            pair = pair.strip()
+            if not pair:
+                continue
+                
+            if '=' not in pair:
+                raise StatusMappingError(f"Invalid mapping format: {pair}. Expected 'source=target'")
+            
+            source_status, target_status = pair.split('=', 1)
+            source_status = source_status.strip()
+            target_status = target_status.strip()
+            
+            if not source_status or not target_status:
+                raise StatusMappingError(f"Empty status in mapping: {pair}")
+            
+            mapping_dict[source_status] = target_status
+        
+        self.set_mapping(mapping_dict)
+    
+    def apply_mapping(self, status: str) -> str:
+        """
+        Apply status mapping to a given status.
+        
+        Args:
+            status: Original status
+            
+        Returns:
+            Mapped status if mapping exists, otherwise original status
+        """
+        if not status:
+            return status
+        
+        if status in self.mapping:
+            mapped_status = self.mapping[status]
+            self.logger.debug(f"Status mapped: {status} -> {mapped_status}")
+            return mapped_status
+        
+        return status
+    
+    def get_mapping(self) -> Dict[str, str]:
+        """
+        Get current status mapping.
+        
+        Returns:
+            Dictionary with current status mappings
+        """
+        return self.mapping.copy()
+    
+    def is_empty(self) -> bool:
+        """
+        Check if mapping is empty.
+        
+        Returns:
+            True if no mappings are defined
+        """
+        return len(self.mapping) == 0
+    
+    def validate(self) -> List[str]:
+        """
+        Validate current mapping and return any issues.
+        
+        Returns:
+            List of validation error messages
+        """
+        errors = []
+        
+        for source_status, target_status in self.mapping.items():
+            if source_status not in self.VALID_STATUSES:
+                errors.append(f"Invalid source status: {source_status}")
+            if target_status not in self.VALID_STATUSES:
+                errors.append(f"Invalid target status: {target_status}")
+        
+        return errors
+    
+    def __str__(self) -> str:
+        """String representation of the mapping."""
+        return str(self.mapping)
+    
+    def __repr__(self) -> str:
+        """Detailed string representation."""
+        return f"StatusMapping({self.mapping})"
+
+
+def create_status_mapping_from_config(config_value: Optional[Dict[str, str]]) -> StatusMapping:
+    """
+    Create StatusMapping from configuration value.
+    
+    Args:
+        config_value: Configuration dictionary or None
+        
+    Returns:
+        StatusMapping instance
+    """
+    if config_value is None:
+        return StatusMapping()
+    
+    return StatusMapping.from_dict(config_value)
+
+
+def create_status_mapping_from_env(env_var_name: str = 'STATUS_MAPPING') -> StatusMapping:
+    """
+    Create StatusMapping from environment variable.
+    
+    Args:
+        env_var_name: Name of environment variable
+        
+    Returns:
+        StatusMapping instance
+    """
+    env_value = os.getenv(env_var_name)
+    if env_value:
+        return StatusMapping.from_env_string(env_value)
+    return StatusMapping()

qase/commons/util/__init__.py

@@ -0,0 +1,9 @@
+from .host_data import get_host_info
+
+__all__ = [
+    get_host_info
+]
+
+
+
+