qase-python-commons 3.3.1__tar.gz → 3.4.0__tar.gz

{qase_python_commons-3.3.1 → qase_python_commons-3.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: qase-python-commons
-Version: 3.3.1
+Version: 3.4.0
 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
@@ -22,8 +22,8 @@ Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 Requires-Dist: certifi>=2024.2.2
 Requires-Dist: attrs>=23.2.0
-Requires-Dist: qase-api-client~=1.1.1
-Requires-Dist: qase-api-v2-client~=1.1.0
+Requires-Dist: qase-api-client~=1.2.0
+Requires-Dist: qase-api-v2-client~=1.2.0
 Requires-Dist: more_itertools
 Provides-Extra: testing
 Requires-Dist: pytest; extra == "testing"

{qase_python_commons-3.3.1 → qase_python_commons-3.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qase-python-commons"
-version = "3.3.1"
+version = "3.4.0"
 description = "A library for Qase TestOps and Qase Report"
 readme = "README.md"
 authors = [{name = "Qase Team", email = "support@qase.io"}]
@@ -30,8 +30,8 @@ requires-python = ">=3.7"
 dependencies = [
     "certifi>=2024.2.2",
     "attrs>=23.2.0",
-    "qase-api-client~=1.1.1",
-    "qase-api-v2-client~=1.1.0",
+    "qase-api-client~=1.2.0",
+    "qase-api-v2-client~=1.2.0",
     "more_itertools"
 ]
 

qase_python_commons-3.4.0/src/qase/commons/client/api_v1_client.py

@@ -0,0 +1,137 @@
+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
+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
+from ..models.config.framework import Video, Trace
+from ..models.config.qaseconfig import QaseConfig
+
+
+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")
+            configuration = Configuration()
+            configuration.api_key['TokenAuth'] = self.config.testops.api.token
+            configuration.ssl_ca_cert = certifi.where()
+            host = self.config.testops.api.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")
+        except Exception as e:
+            self.logger.log(f"Error at preparing API client: {e}", "error")
+            raise ReporterException(e)
+
+    def get_project(self, project_code: str) -> Union[Project, None]:
+        try:
+            self.logger.log_debug(f"Getting project {project_code}")
+            response = ProjectsApi(self.client).get_project(code=project_code)
+            if hasattr(response, 'result'):
+                self.logger.log_debug(f"Project {project_code} found: {response.result.to_json()}")
+                return response.result
+            raise ReporterException("Unable to find given project code")
+        except Exception as e:
+            self.logger.log("Exception when calling ProjectApi->get_project: %s\n" % e, "error")
+            raise ReporterException("Exception when calling ProjectApi")
+
+    def get_environment(self, environment: str, project_code: str) -> Union[str, None]:
+        try:
+            self.logger.log_debug(f"Getting environment {environment}")
+            api_instance = EnvironmentsApi(self.client)
+            response = api_instance.get_environments(code=project_code)
+            if hasattr(response, 'result') and hasattr(response.result, 'entities'):
+                for env in response.result.entities:
+                    if env.slug == environment:
+                        self.logger.log_debug(f"Environment {environment} found: {env.to_json()}")
+                        return env.id
+            self.logger.log_debug(f"Environment {environment} not found")
+            return None
+        except Exception as e:
+            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:
+        api_runs = RunsApi(self.client)
+        self.logger.log_debug(f"Completing run {run_id}")
+        res = api_runs.get_run(project_code, run_id).result
+        if res.status == 1:
+            self.logger.log_debug(f"Run {run_id} already completed")
+            return
+        try:
+            api_runs.complete_run(project_code, run_id)
+            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)
+
+    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}", "error")
+            return None
+
+    def create_test_run(self, project_code: str, title: str, description: str, plan_id=None,
+                        environment_id=None) -> str:
+        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,
+            start_time=datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S")
+        )
+        self.logger.log_debug(f"Creating test run with parameters: {kwargs}")
+        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
+
+        except Exception as e:
+            self.logger.log(f"Error at creating test run: {e}", "error")
+            raise ReporterException(e)
+
+    def check_test_run(self, project_code: str, run_id: int) -> bool:
+        api_runs = RunsApi(self.client)
+        run = api_runs.get_run(code=project_code, id=run_id)
+        if run.result.id:
+            return True
+        return False
+
+    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
+
+    def send_results(self, project_code: str, run_id: str, results: []) -> None:
+        raise NotImplementedError("use ApiV2Client instead")

{qase_python_commons-3.3.1 → qase_python_commons-3.4.0}/src/qase/commons/client/api_v2_client.py

@@ -17,7 +17,7 @@ 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, InternalResult
+from ..models import Attachment, Result
 from ..models.config.qaseconfig import QaseConfig
 from ..models.step import StepType, Step
 
@@ -53,7 +53,7 @@ class ApiV2Client(ApiV1Client):
                                       create_results_request_v2=CreateResultsRequestV2(results=results_to_send))
         self.logger.log_debug(f"Results for run {run_id} sent successfully")
 
-    def _prepare_result(self, project_code: str, result: InternalResult) -> ResultCreate:
+    def _prepare_result(self, project_code: str, result: Result) -> ResultCreate:
         attached = []
         if result.attachments:
             for attachment in result.attachments:
@@ -76,7 +76,7 @@ class ApiV2Client(ApiV1Client):
         result_model_v2 = ResultCreate(
             title=result.get_title(),
             signature=result.signature,
-            testops_id=result.get_testops_id(),
+            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),

{qase_python_commons-3.3.1 → qase_python_commons-3.4.0}/src/qase/commons/config.py

@@ -83,11 +83,6 @@ class ConfigManager:
                                 testops.get("defect")
                             )
 
-                        if testops.get("useV2"):
-                            self.config.testops.set_use_v2(
-                                testops.get("useV2")
-                            )
-
                         if testops.get("plan"):
                             plan = testops.get("plan")
 

{qase_python_commons-3.3.1 → qase_python_commons-3.4.0}/src/qase/commons/models/__init__.py

@@ -1,4 +1,4 @@
-from .result import Result, InternalResult, Field
+from .result import Result, Field
 from .run import Run
 from .attachment import Attachment
 from .relation import Relation
@@ -12,6 +12,5 @@ __all__ = [
     Relation,
     Step,
     Runtime,
-    Field,
-    InternalResult
+    Field
 ]

{qase_python_commons-3.3.1 → qase_python_commons-3.4.0}/src/qase/commons/models/config/testops.py

@@ -20,13 +20,9 @@ class TestopsConfig(BaseModel):
         self.batch = BatchConfig()
         self.plan = PlanConfig()
         self.defect = False
-        self.use_v2 = True
 
     def set_project(self, project: str):
         self.project = project
 
     def set_defect(self, defect):
         self.defect = QaseUtils.parse_bool(defect)
-
-    def set_use_v2(self, use_v2):
-        self.use_v2 = QaseUtils.parse_bool(use_v2)

{qase_python_commons-3.3.1 → qase_python_commons-3.4.0}/src/qase/commons/models/result.py

@@ -1,4 +1,3 @@
-import copy
 import time
 import uuid
 
@@ -71,7 +70,7 @@ class Result(BaseModel):
         self.title: str = title
         self.signature: str = signature
         self.run_id: Optional[str] = None
-        self.testops_id: Optional[List[int]] = None
+        self.testops_ids: Optional[List[int]] = None
         self.execution: Type[Execution] = Execution()
         self.fields: Dict[Type[Field]] = {}
         self.attachments: List[Attachment] = []
@@ -119,96 +118,11 @@ class Result(BaseModel):
             return self.fields[name]
         return None
 
-    def get_testops_id(self) -> Optional[List[int]]:
-        return self.testops_id
+    def get_testops_ids(self) -> Optional[List[int]]:
+        return self.testops_ids
 
     def get_duration(self) -> int:
         return self.execution.duration
 
     def set_run_id(self, run_id: str) -> None:
         self.run_id = run_id
-
-
-class InternalResult(BaseModel):
-    def __init__(self, title: str, signature: str) -> None:
-        self.id: str = str(uuid.uuid4())
-        self.title: str = title
-        self.signature: str = signature
-        self.run_id: Optional[str] = None
-        self.testops_id: Optional[int] = None
-        self.execution: Type[Execution] = Execution()
-        self.fields: Dict[Type[Field]] = {}
-        self.attachments: List[Attachment] = []
-        self.steps: List[Type[Step]] = []
-        self.params: Optional[dict] = {}
-        self.param_groups: Optional[List[List[str]]] = []
-        self.author: Optional[str] = None
-        self.relations: Type[Relation] = None
-        self.muted: bool = False
-        self.message: Optional[str] = None
-        QaseUtils.get_host_data()
-
-    def add_message(self, message: str) -> None:
-        self.message = message
-
-    def add_field(self, field: Type[Field]) -> None:
-        self.fields[field.name] = field.value
-
-    def add_steps(self, steps: List[Type[Step]]) -> None:
-        self.steps = QaseUtils().build_tree(steps)
-
-    def add_attachment(self, attachment: Attachment) -> None:
-        self.attachments.append(attachment)
-
-    def add_param(self, key: str, value: str) -> None:
-        self.params[key] = value
-
-    def add_param_groups(self, values: List[str]) -> None:
-        self.param_groups.append(values)
-
-    def set_relation(self, relation: Relation) -> None:
-        self.relations = relation
-
-    def get_status(self) -> Optional[str]:
-        return self.execution.status
-
-    def get_id(self) -> str:
-        return self.id
-
-    def get_title(self) -> str:
-        return self.title
-
-    def get_field(self, name: str) -> Optional[Type[Field]]:
-        if name in self.fields:
-            return self.fields[name]
-        return None
-
-    def get_testops_id(self) -> Optional[int]:
-        return self.testops_id
-
-    def get_duration(self) -> int:
-        return self.execution.duration
-
-    def set_run_id(self, run_id: str) -> None:
-        self.run_id = run_id
-
-    @classmethod
-    def convert_from_result(cls, result: Result, testops_id: Optional[int] = None):
-        int_result = cls(result.title, result.signature)
-
-        int_result.id = result.id
-        int_result.title = result.title
-        int_result.signature = result.signature
-        int_result.run_id = result.run_id
-        int_result.testops_id = testops_id
-        int_result.execution = copy.deepcopy(result.execution)
-        int_result.fields = result.fields
-        int_result.attachments = result.attachments
-        int_result.steps = result.steps
-        int_result.params = result.params
-        int_result.author = result.author
-        int_result.relations = result.relations
-        int_result.muted = result.muted
-        int_result.message = result.message
-
-        return int_result

{qase_python_commons-3.3.1 → qase_python_commons-3.4.0}/src/qase/commons/reporters/core.py

@@ -6,10 +6,12 @@ from ..logger import Logger
 from .report import QaseReport
 from .testops import QaseTestOps
 
-from ..models import InternalResult, Result, Attachment, Runtime
+from ..models import Result, Attachment, Runtime
 from ..models.config.qaseconfig import Mode
 from typing import Union, List
 
+from ..util import get_host_info
+
 """
     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.
@@ -17,7 +19,7 @@ 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)
@@ -30,6 +32,9 @@ class QaseCoreReporter:
 
         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}")
+
         # Reading reporter mode from config file
         mode = self.config.mode
 
@@ -79,20 +84,8 @@ class QaseCoreReporter:
             try:
                 ts = time.time()
                 self.logger.log_debug(f"Adding result {result}")
-                ids = result.get_testops_id()
-
-                if ids is None:
-                    int_result = InternalResult.convert_from_result(result)
-                    self.reporter.add_result(int_result)
-                else:
-                    first = True
-                    for testops_id in ids:
-                        int_result = InternalResult.convert_from_result(result, testops_id)
-                        if not first:
-                            int_result.execution.duration = 0
-                        else:
-                            first = False
-                        self.reporter.add_result(int_result)
+
+                self.reporter.add_result(result)
 
                 self.logger.log_debug(f"Result {result.get_title()} added")
                 self.overhead += time.time() - ts

{qase_python_commons-3.3.1 → qase_python_commons-3.4.0}/src/qase/commons/reporters/report.py

@@ -3,7 +3,7 @@ import os
 import shutil
 import json
 import re
-from ..models import InternalResult, Run, Attachment
+from ..models import Result, Run, Attachment
 from .. import QaseUtils, Logger
 from ..models.config.connection import Format
 from ..models.config.qaseconfig import QaseConfig
@@ -40,7 +40,7 @@ class QaseReport:
     def complete_worker(self):
         pass
 
-    def add_result(self, result: InternalResult):
+    def add_result(self, result: Result):
         result.set_run_id(self.run_id)
         for attachment in result.attachments:
             self._persist_attachment(attachment)
@@ -91,7 +91,7 @@ class QaseReport:
                     self._persist_attachments_in_steps(step.steps)
 
     # Method saves result to a file
-    def _store_result(self, result: InternalResult):
+    def _store_result(self, result: Result):
         self._store_object(result, self.report_path + "/results/", result.id)
 
     def _check_report_path(self):

{qase_python_commons-3.3.1 → qase_python_commons-3.4.0}/src/qase/commons/reporters/testops.py

@@ -2,11 +2,11 @@ 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.api_v2_client import ApiV2Client
 from ..client.base_api_client import BaseApiClient
-from ..models import InternalResult
+from ..models import Result
 from ..models.config.qaseconfig import QaseConfig
 
 DEFAULT_BATCH_SIZE = 200
@@ -69,10 +69,7 @@ class QaseTestOps:
         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)
+        return ApiV2Client(self.config, self.logger)
 
     def _send_results_threaded(self, results):
         try:
@@ -129,9 +126,9 @@ class QaseTestOps:
         if len(self.results) > 0:
             self._send_results()
 
-    def add_result(self, result: InternalResult) -> None:
+    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 +139,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}{ids[0]}"
         return f"{link}{urllib.parse.quote_plus(title)}"
 
     @staticmethod

qase_python_commons-3.4.0/src/qase/commons/util/__init__.py

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

qase_python_commons-3.4.0/src/qase/commons/util/host_data.py

@@ -0,0 +1,140 @@
+import os
+import platform
+import subprocess
+import json
+import re
+import sys
+from typing import Optional, Dict
+
+HostData = Dict[str, str]
+
+
+def exec_command(command: str, default_value: str = "") -> str:
+    try:
+        result = subprocess.run(
+            command,
+            shell=True,
+            check=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True
+        )
+        return result.stdout.strip()
+    except Exception as e:
+        print(f"Error executing command '{command}': {e}", file=sys.stderr)
+        return default_value
+
+
+def get_detailed_os_info() -> str:
+    system = platform.system().lower()
+    try:
+        if system == "windows":
+            return exec_command("ver")
+        elif system == "darwin":
+            return exec_command("sw_vers -productVersion")
+        else:
+            try:
+                if os.path.exists("/etc/os-release"):
+                    with open("/etc/os-release", "r") as f:
+                        os_release = f.read()
+                    match = re.search(r'PRETTY_NAME="(.+?)"', os_release)
+                    if match:
+                        return match.group(1)
+            except Exception:
+                pass
+            return platform.release()
+    except Exception as e:
+        print(f"Error getting detailed OS info: {e}", file=sys.stderr)
+        return platform.release()
+
+
+def get_package_version(package_name: Optional[str]) -> Optional[str]:
+    if not package_name:
+        return ""
+    try:
+        pip_output = exec_command(f"pip show {package_name}")
+        if pip_output:
+            version_match = re.search(r'Version:\s*(\S+)', pip_output)
+            if version_match:
+                return version_match.group(1)
+        pip_list_output = exec_command("pip list --format=json")
+        if pip_list_output:
+            packages = json.loads(pip_list_output)
+            for pkg in packages:
+                if pkg.get("name", "").lower() == package_name.lower():
+                    return pkg.get("version")
+        try:
+            import importlib.metadata
+            return importlib.metadata.version(package_name)
+        except (ImportError, importlib.metadata.PackageNotFoundError):
+            pass
+        return ""
+    except Exception as e:
+        print(f"Error getting version for package {package_name}: {e}", file=sys.stderr)
+        return ""
+
+
+def find_package_in_requirements(package_name: Optional[str]) -> Optional[str]:
+    if not package_name:
+        return ""
+    try:
+        possible_req_files = ['requirements.txt', 'requirements/base.txt', 'requirements/dev.txt']
+        for req_file in possible_req_files:
+            if os.path.exists(req_file):
+                with open(req_file, 'r') as f:
+                    for line in f:
+                        if line.startswith(package_name):
+                            version_match = re.search(r'[=<>~]{1,2}([\d.]+)', line)
+                            if version_match:
+                                return version_match.group(1)
+        return ""
+    except Exception as e:
+        print(f"Error reading requirements for {package_name}: {e}", file=sys.stderr)
+        return ""
+
+
+def get_host_info(framework: Optional[str], reporter_name: Optional[str]) -> HostData:
+    try:
+        python_version = platform.python_version()
+        pip_version = exec_command("pip --version")
+        if pip_version:
+            pip_match = re.search(r'pip\s+(\S+)', pip_version)
+            pip_version = pip_match.group(1) if pip_match else ""
+        framework_version = get_package_version(framework) or find_package_in_requirements(framework) or ""
+        reporter_version = get_package_version(reporter_name) or find_package_in_requirements(reporter_name) or ""
+        commons_version = get_package_version("qase-python-commons") or find_package_in_requirements(
+            "qase-python-commons") or ""
+        api_client_version_1 = get_package_version("qase-api-client") or find_package_in_requirements(
+            "qase-api-client") or ""
+        api_client_version_2 = get_package_version("qase-api-v2-client") or find_package_in_requirements(
+            "qase-api-v2-client") or ""
+        return {
+            "system": platform.system().lower(),
+            "machineName": platform.node(),
+            "release": platform.release(),
+            "version": get_detailed_os_info(),
+            "arch": platform.machine(),
+            "python": python_version,
+            "pip": pip_version,
+            "framework": framework_version,
+            "reporter": reporter_version,
+            "commons": commons_version,
+            "apiClientV1": api_client_version_1,
+            "apiClientV2": api_client_version_2
+        }
+    except Exception as e:
+        print(f"Error getting host info: {e}", file=sys.stderr)
+        return {
+            "system": platform.system().lower(),
+            "machineName": platform.node(),
+            "release": platform.release(),
+            "version": "",
+            "arch": platform.machine(),
+            "python": "",
+            "pip": "",
+            "framework": "",
+            "reporter": "",
+            "commons": "",
+            "apiClientV1": "",
+            "apiClientV2": ""
+        }

{qase_python_commons-3.3.1 → qase_python_commons-3.4.0}/src/qase_python_commons.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: qase-python-commons
-Version: 3.3.1
+Version: 3.4.0
 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
@@ -22,8 +22,8 @@ Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 Requires-Dist: certifi>=2024.2.2
 Requires-Dist: attrs>=23.2.0
-Requires-Dist: qase-api-client~=1.1.1
-Requires-Dist: qase-api-v2-client~=1.1.0
+Requires-Dist: qase-api-client~=1.2.0
+Requires-Dist: qase-api-v2-client~=1.2.0
 Requires-Dist: more_itertools
 Provides-Extra: testing
 Requires-Dist: pytest; extra == "testing"

{qase_python_commons-3.3.1 → qase_python_commons-3.4.0}/src/qase_python_commons.egg-info/SOURCES.txt

@@ -34,6 +34,8 @@ src/qase/commons/reporters/__init__.py
 src/qase/commons/reporters/core.py
 src/qase/commons/reporters/report.py
 src/qase/commons/reporters/testops.py
+src/qase/commons/util/__init__.py
+src/qase/commons/util/host_data.py
 src/qase/commons/validators/base.py
 src/qase_python_commons.egg-info/PKG-INFO
 src/qase_python_commons.egg-info/SOURCES.txt

{qase_python_commons-3.3.1 → qase_python_commons-3.4.0}/src/qase_python_commons.egg-info/requires.txt

@@ -1,7 +1,7 @@
 certifi>=2024.2.2
 attrs>=23.2.0
-qase-api-client~=1.1.1
-qase-api-v2-client~=1.1.0
+qase-api-client~=1.2.0
+qase-api-v2-client~=1.2.0
 more_itertools
 
 [testing]

qase_python_commons-3.3.1/src/qase/commons/client/api_v1_client.py

@@ -1,302 +0,0 @@
-from datetime import datetime, timezone
-from typing import Dict, Union
-
-import certifi
-from qase.api_client_v1 import ApiClient, ProjectsApi, Project, EnvironmentsApi, RunsApi, AttachmentsApi, \
-    AttachmentGet, RunCreate, ResultsApi, ResultcreateBulk, AuthorsApi
-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, InternalResult, Step
-from ..models.config.framework import Video, Trace
-from ..models.config.qaseconfig import QaseConfig
-from ..models.step import StepType
-
-
-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")
-            configuration = Configuration()
-            configuration.api_key['TokenAuth'] = self.config.testops.api.token
-            configuration.ssl_ca_cert = certifi.where()
-            host = self.config.testops.api.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")
-        except Exception as e:
-            self.logger.log(f"Error at preparing API client: {e}", "error")
-            raise ReporterException(e)
-
-    def get_project(self, project_code: str) -> Union[Project, None]:
-        try:
-            self.logger.log_debug(f"Getting project {project_code}")
-            response = ProjectsApi(self.client).get_project(code=project_code)
-            if hasattr(response, 'result'):
-                self.logger.log_debug(f"Project {project_code} found: {response.result.to_json()}")
-                return response.result
-            raise ReporterException("Unable to find given project code")
-        except Exception as e:
-            self.logger.log("Exception when calling ProjectApi->get_project: %s\n" % e, "error")
-            raise ReporterException("Exception when calling ProjectApi")
-
-    def get_environment(self, environment: str, project_code: str) -> Union[str, None]:
-        try:
-            self.logger.log_debug(f"Getting environment {environment}")
-            api_instance = EnvironmentsApi(self.client)
-            response = api_instance.get_environments(code=project_code)
-            if hasattr(response, 'result') and hasattr(response.result, 'entities'):
-                for env in response.result.entities:
-                    if env.slug == environment:
-                        self.logger.log_debug(f"Environment {environment} found: {env.to_json()}")
-                        return env.id
-            self.logger.log_debug(f"Environment {environment} not found")
-            return None
-        except Exception as e:
-            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:
-        api_runs = RunsApi(self.client)
-        self.logger.log_debug(f"Completing run {run_id}")
-        res = api_runs.get_run(project_code, run_id).result
-        if res.status == 1:
-            self.logger.log_debug(f"Run {run_id} already completed")
-            return
-        try:
-            api_runs.complete_run(project_code, run_id)
-            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)
-
-    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}", "error")
-            return None
-
-    def create_test_run(self, project_code: str, title: str, description: str, plan_id=None,
-                        environment_id=None) -> str:
-        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,
-            start_time=datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S")
-        )
-        self.logger.log_debug(f"Creating test run with parameters: {kwargs}")
-        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
-
-        except Exception as e:
-            self.logger.log(f"Error at creating test run: {e}", "error")
-            raise ReporterException(e)
-
-    def check_test_run(self, project_code: str, run_id: int) -> bool:
-        api_runs = RunsApi(self.client)
-        run = api_runs.get_run(code=project_code, id=run_id)
-        if run.result.id:
-            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: InternalResult) -> 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.relations is not None and result.relations.suite is not None and len(
-                result.relations.suite.data) != 0:
-            suites = []
-
-            for raw in result.relations.suite.data:
-                suites.append(raw.title)
-
-            suite = "\t".join(suites)
-
-        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 = []
-
-        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
-        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:
-            return None
-
-        self.__authors[author] = authors.result.entities[0].author_id
-
-        return authors.result.entities[0].author_id
-
-    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