qase-python-commons 5.1.5__tar.gz → 5.1.7__tar.gz

{qase_python_commons-5.1.5 → qase_python_commons-5.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qase-python-commons
-Version: 5.1.5
+Version: 5.1.7
 Summary: A library for Qase TestOps and Qase Report
 Author-email: Qase Team <support@qase.io>
 Project-URL: Homepage, https://github.com/qase-tms/qase-python/tree/main/qase-python-commons
@@ -137,7 +137,7 @@ The reporter mode is set via the `mode` option:
 | Description | Config file | Environment variable | Default | Required |
 |-------------|-------------|---------------------|---------|----------|
 | API token | `testops.api.token` | `QASE_TESTOPS_API_TOKEN` | — | Yes* |
-| API host | `testops.api.host` | `QASE_TESTOPS_API_HOST` | `qase.io` | No |
+| Qase API host. `qase.io` is the US cluster; set `eu.qase.io` if your workspace is on the EU cluster (you open Qase at `app-eu.qase.io`) | `testops.api.host` | `QASE_TESTOPS_API_HOST` | `qase.io` | Yes, on the EU cluster |
 | Request timeout, seconds | `testops.api.timeout` | `QASE_TESTOPS_API_TIMEOUT` | `30` | No |
 | Upload attempts | `testops.api.retries` | `QASE_TESTOPS_API_RETRIES` | `3` | No |
 | Retry backoff base, seconds | `testops.api.retryBackoff` | `QASE_TESTOPS_API_RETRY_BACKOFF` | `2` | No |
@@ -297,6 +297,7 @@ export QASE_DEBUG="false"
 
 # TestOps
 export QASE_TESTOPS_API_TOKEN="<token>"
+export QASE_TESTOPS_API_HOST="qase.io"  # eu.qase.io for the EU cluster
 export QASE_TESTOPS_PROJECT="DEMO"
 export QASE_TESTOPS_RUN_TITLE="Automated Run"
 export QASE_TESTOPS_RUN_COMPLETE="true"

{qase_python_commons-5.1.5 → qase_python_commons-5.1.7}/README.md

@@ -102,7 +102,7 @@ The reporter mode is set via the `mode` option:
 | Description | Config file | Environment variable | Default | Required |
 |-------------|-------------|---------------------|---------|----------|
 | API token | `testops.api.token` | `QASE_TESTOPS_API_TOKEN` | — | Yes* |
-| API host | `testops.api.host` | `QASE_TESTOPS_API_HOST` | `qase.io` | No |
+| Qase API host. `qase.io` is the US cluster; set `eu.qase.io` if your workspace is on the EU cluster (you open Qase at `app-eu.qase.io`) | `testops.api.host` | `QASE_TESTOPS_API_HOST` | `qase.io` | Yes, on the EU cluster |
 | Request timeout, seconds | `testops.api.timeout` | `QASE_TESTOPS_API_TIMEOUT` | `30` | No |
 | Upload attempts | `testops.api.retries` | `QASE_TESTOPS_API_RETRIES` | `3` | No |
 | Retry backoff base, seconds | `testops.api.retryBackoff` | `QASE_TESTOPS_API_RETRY_BACKOFF` | `2` | No |
@@ -262,6 +262,7 @@ export QASE_DEBUG="false"
 
 # TestOps
 export QASE_TESTOPS_API_TOKEN="<token>"
+export QASE_TESTOPS_API_HOST="qase.io"  # eu.qase.io for the EU cluster
 export QASE_TESTOPS_PROJECT="DEMO"
 export QASE_TESTOPS_RUN_TITLE="Automated Run"
 export QASE_TESTOPS_RUN_COMPLETE="true"

{qase_python_commons-5.1.5 → qase_python_commons-5.1.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qase-python-commons"
-version = "5.1.5"
+version = "5.1.7"
 description = "A library for Qase TestOps and Qase Report"
 readme = "README.md"
 authors = [{name = "Qase Team", email = "support@qase.io"}]

{qase_python_commons-5.1.5 → qase_python_commons-5.1.7}/src/qase/commons/client/api_v1_client.py

@@ -9,6 +9,7 @@ from qase.api_client_v1.configuration import Configuration
 from .. import Logger
 from .base_api_client import BaseApiClient
 from ..retry import send_with_retry
+from ..util.api_host import get_web_app_url
 from ..exceptions.reporter import ReporterException
 from ..models import Attachment
 from ..models.config.framework import Video, Trace
@@ -31,12 +32,11 @@ class ApiV1Client(BaseApiClient):
             # pinned off so it cannot multiply with the application-level one.
             configuration.retries = 0
             host = self.config.testops.api.host
+            self.web = get_web_app_url(host)
             if host == 'qase.io':
                 configuration.host = f'https://api.{host}/v1'
-                self.web = f'https://app.{host}'
             else:
                 configuration.host = f'https://api-{host}/v1'
-                self.web = f'https://{host}'
 
             self.client = ApiClient(configuration)
             self.logger.log_debug("API client prepared")

{qase_python_commons-5.1.5 → qase_python_commons-5.1.7}/src/qase/commons/client/api_v2_client.py

@@ -20,6 +20,7 @@ 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.api_host import get_web_app_url
 from ..util.host_data import HostData
 
 
@@ -42,12 +43,11 @@ class ApiV2Client(ApiV1Client):
             # 9 requests, the opposite of what is wanted on a 429.
             configuration.retries = 0
             host = self.config.testops.api.host
+            self.web = get_web_app_url(host)
             if host == 'qase.io':
                 configuration.host = f'https://api.{host}/v2'
-                self.web = f'https://app.{host}'
             else:
                 configuration.host = f'https://api-{host}/v2'
-                self.web = f'https://{host}'
 
             self.client_v2 = ApiClient(configuration)
             

qase_python_commons-5.1.7/src/qase/commons/config.py

@@ -0,0 +1,396 @@
+import os
+import json
+from contextlib import contextmanager
+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.__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] = []
+        if self.config.mode is Mode.testops or self.config.fallback is Mode.testops:
+            if self.config.testops.api.token is None:
+                errors.append("Testops token is not set")
+
+            if self.config.testops.project is None:
+                errors.append("Testops project is not set")
+
+        if self.config.mode is Mode.testops_multi or self.config.fallback is Mode.testops_multi:
+            if self.config.testops.api.token is None:
+                errors.append("Testops token is not set")
+
+            if not self.config.testops_multi.projects or len(self.config.testops_multi.projects) == 0:
+                errors.append("Testops multi: at least one project must be configured")
+
+            for project in self.config.testops_multi.projects:
+                if not project.code:
+                    errors.append(f"Testops multi: project code is required for all projects")
+
+        if len(errors) > 0:
+            self.logger.log("Config validation failed", "error")
+            for error in errors:
+                self.logger.log(error, "error")
+            raise Exception("Config validation failed")
+
+    def __str__(self):
+        return json.dumps(self.config, indent=4, sort_keys=True)
+
+    @contextmanager
+    def __option(self, name: str):
+        # One invalid value must not discard the settings loaded after it.
+        try:
+            yield
+        except Exception as e:
+            self.logger.log(f"Ignoring invalid value for {name}: {e}", "error")
+
+    def __load_file_config(self):
+        if not os.path.exists(self.__config_file):
+            return
+
+        try:
+            with open(self.__config_file, "r") as file:
+                config = json.load(file)
+        except Exception as e:
+            self.logger.log(f"Failed to load config from file: {e}", "error")
+            return
+
+        with self.__option("mode"):
+            if config.get("mode"):
+                self.config.set_mode(config.get("mode"))
+
+        with self.__option("fallback"):
+            if config.get("fallback"):
+                self.config.set_fallback(config.get("fallback"))
+
+        with self.__option("environment"):
+            if config.get("environment"):
+                self.config.set_environment(config.get("environment"))
+
+        with self.__option("rootSuite"):
+            if config.get("rootSuite"):
+                self.config.set_root_suite(config.get("rootSuite"))
+
+        with self.__option("profilers"):
+            if config.get("profilers"):
+                self.config.set_profilers(config.get("profilers"))
+
+        with self.__option("debug"):
+            if config.get("debug") is not None:
+                self.config.set_debug(config.get("debug"))
+
+        with self.__option("excludeParams"):
+            if config.get("excludeParams"):
+                self.config.set_exclude_params(config.get("excludeParams"))
+
+        with self.__option("statusMapping"):
+            if config.get("statusMapping"):
+                self.config.set_status_mapping(config.get("statusMapping"))
+
+        with self.__option("executionPlan.path"):
+            execution_plan = config.get("executionPlan") or {}
+            if execution_plan.get("path"):
+                self.config.execution_plan.set_path(execution_plan.get("path"))
+
+        testops = config.get("testops") or {}
+        api = testops.get("api") or {}
+
+        with self.__option("testops.api.host"):
+            if api.get("host"):
+                self.config.testops.api.set_host(api.get("host"))
+
+        with self.__option("testops.api.token"):
+            if api.get("token"):
+                self.config.testops.api.set_token(api.get("token"))
+
+        with self.__option("testops.api.timeout"):
+            if api.get("timeout"):
+                self.config.testops.api.set_timeout(api.get("timeout"))
+
+        # `is not None`, not truthiness: 0 is a valid value
+        # for both, meaning "no retries" / "no backoff".
+        with self.__option("testops.api.retries"):
+            if api.get("retries") is not None:
+                self.config.testops.api.set_retries(api.get("retries"))
+
+        with self.__option("testops.api.retryBackoff"):
+            if api.get("retryBackoff") is not None:
+                self.config.testops.api.set_retry_backoff(api.get("retryBackoff"))
+
+        with self.__option("testops.project"):
+            if testops.get("project"):
+                self.config.testops.set_project(testops.get("project"))
+
+        with self.__option("testops.defect"):
+            if testops.get("defect") is not None:
+                self.config.testops.set_defect(testops.get("defect"))
+
+        with self.__option("testops.plan.id"):
+            plan = testops.get("plan") or {}
+            if plan.get("id"):
+                self.config.testops.plan.set_id(plan.get("id"))
+
+        run = testops.get("run") or {}
+
+        with self.__option("testops.run.id"):
+            if run.get("id"):
+                self.config.testops.run.set_id(run.get("id"))
+
+        with self.__option("testops.run.title"):
+            if run.get("title"):
+                self.config.testops.run.set_title(run.get("title"))
+
+        with self.__option("testops.run.description"):
+            if run.get("description"):
+                self.config.testops.run.set_description(run.get("description"))
+
+        with self.__option("testops.run.complete"):
+            if run.get("complete") is not None:
+                self.config.testops.run.set_complete(run.get("complete"))
+
+        with self.__option("testops.run.tags"):
+            if run.get("tags"):
+                self.config.testops.run.set_tags([tag.strip() for tag in run.get("tags")])
+
+        with self.__option("testops.run.externalLink"):
+            if run.get("externalLink"):
+                self.config.testops.run.set_external_link(run.get("externalLink"))
+
+        with self.__option("testops.batch.size"):
+            batch = testops.get("batch") or {}
+            if batch.get("size"):
+                self.config.testops.batch.set_size(batch.get("size"))
+
+        configurations = testops.get("configurations") or {}
+
+        with self.__option("testops.configurations.values"):
+            for value in configurations.get("values") or []:
+                if value.get("name") and value.get("value"):
+                    self.config.testops.configurations.add_value(
+                        value.get("name"), value.get("value"))
+
+        with self.__option("testops.configurations.createIfNotExists"):
+            if configurations.get("createIfNotExists") is not None:
+                self.config.testops.configurations.set_create_if_not_exists(
+                    configurations.get("createIfNotExists"))
+
+        with self.__option("testops.statusFilter"):
+            status_filter = testops.get("statusFilter")
+            if status_filter:
+                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(',')])
+
+        with self.__option("testops.showPublicReportLink"):
+            if testops.get("showPublicReportLink") is not None:
+                self.config.testops.set_show_public_report_link(testops.get("showPublicReportLink"))
+
+        with self.__option("testops_multi"):
+            if config.get("testops_multi"):
+                self.config.set_testops_multi(config.get("testops_multi"))
+
+        report = config.get("report") or {}
+        connection = report.get("connection") or {}
+
+        with self.__option("report.driver"):
+            if report.get("driver"):
+                self.config.report.set_driver(report.get("driver"))
+
+        with self.__option("report.connection.path"):
+            if connection.get("path"):
+                self.config.report.connection.set_path(connection.get("path"))
+
+        with self.__option("report.connection.format"):
+            if connection.get("format"):
+                self.config.report.connection.set_format(connection.get("format"))
+
+        pytest = (config.get("framework") or {}).get("pytest") or {}
+        xfail_status = pytest.get("xfailStatus") or {}
+
+        with self.__option("framework.pytest.captureLogs"):
+            if pytest.get("captureLogs") is not None:
+                self.config.framework.pytest.set_capture_logs(pytest.get("captureLogs"))
+
+        with self.__option("framework.pytest.xfailStatus.xfail"):
+            if xfail_status.get("xfail"):
+                self.config.framework.pytest.xfail_status.set_xfail(xfail_status.get("xfail"))
+
+        with self.__option("framework.pytest.xfailStatus.xpass"):
+            if xfail_status.get("xpass"):
+                self.config.framework.pytest.xfail_status.set_xpass(xfail_status.get("xpass"))
+
+        with self.__option("logging"):
+            if config.get("logging"):
+                self.config.set_logging(config.get("logging"))
+
+    def __load_env_config(self):
+        for key, value in os.environ.items():
+            # CI templates like QASE_TESTOPS_RUN_ID=${RUN_ID} leave the variable
+            # set but empty; that means "not configured", not an invalid value.
+            if not key.startswith('QASE_') or not value.strip():
+                continue
+            with self.__option(key):
+                self.__apply_env_var(key, value)
+
+    def __apply_env_var(self, key: str, value: str):
+        if key == 'QASE_MODE':
+            self.config.set_mode(value)
+
+        if key == 'QASE_FALLBACK':
+            self.config.set_fallback(value)
+
+        if key == 'QASE_ENVIRONMENT':
+            self.config.set_environment(value)
+
+        if key == 'QASE_ROOT_SUITE':
+            self.config.set_root_suite(value)
+
+        if key == 'QASE_PROFILERS':
+            self.config.set_profilers(value.split(','))
+
+        if key == 'QASE_PROFILER_NETWORK_EXCLUDE_HOSTS':
+            self.config.network_profiler.set_exclude_hosts(
+                [h.strip() for h in value.split(',')]
+            )
+
+        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)
+
+        if key == 'QASE_TESTOPS_API_HOST':
+            self.config.testops.api.set_host(value)
+
+        if key == 'QASE_TESTOPS_API_TOKEN':
+            self.config.testops.api.set_token(value)
+
+        if key == 'QASE_TESTOPS_API_TIMEOUT':
+            self.config.testops.api.set_timeout(value)
+
+        if key == 'QASE_TESTOPS_API_RETRIES':
+            self.config.testops.api.set_retries(value)
+
+        if key == 'QASE_TESTOPS_API_RETRY_BACKOFF':
+            self.config.testops.api.set_retry_backoff(value)
+
+        if key == 'QASE_TESTOPS_PROJECT':
+            self.config.testops.set_project(value)
+
+        if key == 'QASE_TESTOPS_DEFECT':
+            self.config.testops.set_defect(value)
+
+        if key == 'QASE_TESTOPS_PLAN_ID':
+            self.config.testops.plan.set_id(int(value.strip()))
+
+        if key == 'QASE_TESTOPS_RUN_ID':
+            self.config.testops.run.set_id(int(value.strip()))
+
+        if key == 'QASE_TESTOPS_RUN_TITLE':
+            self.config.testops.run.set_title(value)
+
+        if key == 'QASE_TESTOPS_RUN_DESCRIPTION':
+            self.config.testops.run.set_description(value)
+
+        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(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)
+
+        if key == 'QASE_REPORT_CONNECTION_PATH':
+            self.config.report.connection.set_path(value)
+
+        if key == 'QASE_REPORT_CONNECTION_FORMAT':
+            self.config.report.connection.set_format(value)
+
+        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))

{qase_python_commons-5.1.5 → qase_python_commons-5.1.7}/src/qase/commons/models/config/batch.py

@@ -8,6 +8,7 @@ class BatchConfig(BaseModel):
         self.size = 200
 
     def set_size(self, size: int):
-        if size > 200 or size == 0:
+        size = int(size)
+        if size > 200 or size < 1:
             raise ValueError("Batch size should be greater than 0 and no greater than 200")
         self.size = size

{qase_python_commons-5.1.5 → qase_python_commons-5.1.7}/src/qase/commons/models/run.py

@@ -50,18 +50,18 @@ class Run(BaseModel):
                  title: str,
                  start_time: float,
                  end_time: float,
-                 results: List[str] = [],
-                 threads: List[str] = [],
-                 suites: List[str] = [],
+                 results: Optional[List[str]] = None,
+                 threads: Optional[List[str]] = None,
+                 suites: Optional[List[str]] = None,
                  environment: Optional[str] = None
                  ):
         self.host_data = None
         self.title = title
         self.execution = RunExecution(start_time=start_time, end_time=end_time)
         self.stats = RunStats()
-        self.results = results
-        self.threads = threads
-        self.suites = suites
+        self.results = results if results is not None else []
+        self.threads = threads if threads is not None else []
+        self.suites = suites if suites is not None else []
         self.environment = environment
 
     def add_result(self, result: dict):
@@ -84,11 +84,8 @@ class Run(BaseModel):
 
     def _extract_path_from_relations(self, relations_dict):
 
-        titles = []
-        if "relations" in relations_dict and "suite" in relations_dict["relations"]:
-            if "data" in relations_dict["relations"]["suite"]:
-                data_list = relations_dict["relations"]["suite"]["data"]
-                titles = [item["title"] for item in data_list if "title" in item]
+        suite = (relations_dict.get("relations") or {}).get("suite") or {}
+        titles = [item["title"] for item in suite.get("data") or [] if "title" in item]
 
         path = "/".join(titles)
 

{qase_python_commons-5.1.5 → qase_python_commons-5.1.7}/src/qase/commons/reporters/core.py

@@ -179,9 +179,13 @@ class QaseCoreReporter:
                 self.overhead += time.time() - ts
                 return run_id
             except Exception as e:
-                self.logger.log('Failed to start run, disabling reporting', 'info')
+                self.logger.log('Failed to start run', 'info')
                 self.logger.log(e, 'error')
-                self.reporter = None
+                if self._can_fallback():
+                    self._run_fallback()
+                else:
+                    self.logger.log('Disabling reporting', 'info')
+                    self.reporter = None
                 return None
 
         return None
@@ -198,6 +202,12 @@ class QaseCoreReporter:
                 self.logger.log('Failed to complete run', 'info')
                 self.logger.log(e, 'error')
 
+            if self._can_fallback() and self._has_undelivered_results():
+                self.logger.log('Some results were not delivered, saving all results with the fallback reporter',
+                                'info')
+                self._run_fallback()
+                self.complete_run()
+
     def add_result(self, result: Result) -> None:
         if self.reporter:
             try:
@@ -289,21 +299,25 @@ class QaseCoreReporter:
     def get_execution_plan(self) -> Union[None, List[int]]:
         return self._execution_plan
 
+    def _can_fallback(self) -> bool:
+        # After a failed TestOps init the fallback is already the active reporter;
+        # restarting it would wipe the results it has written.
+        return self.fallback is not None and self.reporter is not self.fallback
+
+    def _has_undelivered_results(self) -> bool:
+        lost = getattr(self.reporter, 'lost_results', 0)
+        if isinstance(lost, dict):
+            lost = sum(lost.values())
+        return isinstance(lost, int) and lost > 0
+
     def _run_fallback(self) -> None:
-        if self.fallback:
+        if self._can_fallback():
             try:
                 results = self.reporter.get_results()
 
                 self.fallback.start_run()
                 self.reporter = self.fallback
-                # Handle both single project (list) and multi-project (dict) results
-                if isinstance(results, dict):
-                    # Multi-project mode: results is dict of project -> list of results
-                    for project_code, project_results in results.items():
-                        self.reporter.set_results({project_code: project_results})
-                else:
-                    # Single project mode: results is list
-                    self.reporter.set_results(results)
+                self.reporter.set_results(results)
                 self.fallback = None
             except Exception as e:
                 # Log error, disable reporting and continue

{qase_python_commons-5.1.5 → qase_python_commons-5.1.7}/src/qase/commons/reporters/report.py

@@ -112,7 +112,13 @@ class QaseReport:
         return self.results
 
     def set_results(self, results):
-        self.results = results
+        # Called on fallback with what the TestOps reporter held: a list, or
+        # a dict of lists per project. The report is compiled from results/,
+        # so they have to be written there, not kept in memory.
+        if isinstance(results, dict):
+            results = [result for project_results in results.values() for result in project_results]
+        for result in results:
+            self.add_result(result)
 
     def _persist_attachment(self, attachment: Attachment):
         if attachment.content:

{qase_python_commons-5.1.5 → qase_python_commons-5.1.7}/src/qase/commons/reporters/testops.py

@@ -9,6 +9,7 @@ from ..client.base_api_client import BaseApiClient
 from ..models import Result
 from ..models.config.qaseconfig import QaseConfig
 from ..retry import send_with_retry
+from ..util.api_host import get_web_app_url
 
 DEFAULT_BATCH_SIZE = 200
 DEFAULT_THREAD_COUNT = 4
@@ -20,7 +21,7 @@ class QaseTestOps:
     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.__baseUrl = get_web_app_url(config.testops.api.host)
         self.client = client
 
         run_id = self.config.testops.run.id
@@ -39,6 +40,7 @@ class QaseTestOps:
         self.count_running_threads = 0
         # Results in batches that could not be delivered after all retries.
         self.lost_results = 0
+        self.undelivered = []
 
         environment = self.config.environment
         if environment:
@@ -87,6 +89,7 @@ class QaseTestOps:
             # nothing acted on, which is how the loss stayed invisible.
             with self.lock:
                 self.lost_results += len(results)
+                self.undelivered.extend(results)
                 self.logger.log(
                     f"Failed to send {len(results)} results for run {self.run_id} "
                     f"after {self.config.testops.api.retries} attempt(s): {e}",
@@ -196,7 +199,7 @@ class QaseTestOps:
             self._send_results()
 
     def get_results(self) -> List:
-        return self.results + self.processed
+        return self.results + self.processed + self.undelivered
 
     def set_results(self, results) -> None:
         self.results = results
@@ -210,10 +213,3 @@ class QaseTestOps:
         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
-    def __get_host(host: str):
-        if host == 'qase.io':
-            return 'https://app.qase.io'
-
-        return f'https://{host.replace("api", "app")}'