qase-python-commons 3.0.0__tar.gz → 3.0.2b2__tar.gz

{qase_python_commons-3.0.0 → qase_python_commons-3.0.2b2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: qase-python-commons
-Version: 3.0.0
+Version: 3.0.2b2
 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/master/qase-python-commons
@@ -22,7 +22,7 @@ Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 Requires-Dist: certifi>=2024.2.2
 Requires-Dist: attrs>=23.2.0
-Requires-Dist: qaseio
+Requires-Dist: qase-api-client~=1.0.0b2
 Requires-Dist: more_itertools
 Provides-Extra: testing
 Requires-Dist: pytest; extra == "testing"

{qase_python_commons-3.0.0 → qase_python_commons-3.0.2b2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qase-python-commons"
-version = "3.0.0"
+version = "3.0.2b2"
 description = "A library for Qase TestOps and Qase Report"
 readme = "README.md"
 authors = [{name = "Qase Team", email = "support@qase.io"}]
@@ -30,7 +30,7 @@ requires-python = ">=3.7"
 dependencies = [
     "certifi>=2024.2.2",
     "attrs>=23.2.0",
-    "qaseio",
+    "qase-api-client~=1.0.0b2",
     "more_itertools"
 ]
 
@@ -99,4 +99,4 @@ exclude_also = [
     "@(abc\\.)?abstractmethod",
     ]
 
-ignore_errors = false
+ignore_errors = false

qase_python_commons-3.0.2b2/src/qase/commons/client/api_v1_client.py

@@ -0,0 +1,247 @@
+from typing import Dict, Union
+
+import certifi
+from qase.api_client_v1 import ApiClient, ProjectsApi, Project, EnvironmentsApi, RunsApi, AttachmentsApi, \
+    AttachmentGet, RunCreate, ResultsApi, ResultcreateBulk
+from qase.api_client_v1.configuration import Configuration
+from .. import ConfigManager, Logger
+from .base_api_client import BaseApiClient
+from ..exceptions.reporter import ReporterException
+from ..models import Attachment, Result, Step
+from ..models.step import StepType
+
+
+class ApiV1Client(BaseApiClient):
+    def __init__(self, config: ConfigManager, logger: Logger):
+        self.logger = logger
+        self.config = config
+
+        try:
+            self.logger.log_debug("Preparing API client")
+            configuration = Configuration()
+            configuration.api_key['TokenAuth'] = self.config.get('testops.api.token')
+            configuration.ssl_ca_cert = certifi.where()
+            host = self.config.get('testops.api.host', 'qase.io')
+            if self.config.get('testops.api.enterprise', False, bool):
+                configuration.host = f'https://api-{host}/v1'
+                self.web = f'https://{host}'
+            else:
+                configuration.host = f'https://api.{host}/v1'
+                self.web = f'https://app.{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"Run {run_id} was completed successfully", "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")
+            raise ReporterException(e)
+
+    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
+        )
+        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})
+            )
+
+            self.logger.log(f"Test run was created: {self.web}/run/{project_code}/dashboard/{result.result.id}", "info")
+
+            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: int, results: []) -> None:
+        api_results = ResultsApi(self.client)
+        results_to_send = [self._prepare_result(project_code, result) for result in results]
+        self.logger.log_debug(f"Sending results for run {run_id}: {results_to_send}")
+        api_results.create_result_bulk(
+            code=project_code,
+            id=run_id,
+            resultcreate_bulk=ResultcreateBulk(
+                results=results_to_send
+            )
+        )
+        self.logger.log_debug(f"Results for run {run_id} sent successfully")
+
+    def _prepare_result(self, project_code: str, result: Result) -> Dict:
+        attached = []
+        if result.attachments:
+            for attachment in result.attachments:
+                attached.extend(self._upload_attachment(project_code, attachment))
+
+        steps = []
+        for step in result.steps:
+            prepared = self._prepare_step(project_code, step)
+            steps.append(prepared)
+
+        case_data = {
+            "title": result.get_title(),
+            "description": result.get_field('description'),
+            "preconditions": result.get_field('preconditions'),
+            "postconditions": result.get_field('postconditions'),
+        }
+
+        for key, param in result.params.items():
+            # Hack to match old TestOps API
+            if param == "":
+                result.params[key] = "empty"
+
+        if result.get_field('severity'):
+            case_data["severity"] = result.get_field('severity')
+
+        if result.get_field('priority'):
+            case_data["priority"] = result.get_field('priority')
+
+        if result.get_field('layer'):
+            case_data["layer"] = result.get_field('layer')
+
+        if result.get_suite_title():
+            case_data["suite_title"] = "\t".join(result.get_suite_title().split("."))
+
+        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,
+            "defect": self.config.get('testops.defect', False, bool),
+        }
+
+        test_ops_id = result.get_testops_id()
+
+        if test_ops_id:
+            result_model["case_id"] = test_ops_id
+            result_model["case"] = None
+            return result_model
+
+        result_model["case_id"] = None
+        result_model["case"] = case_data
+
+        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.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:
+                    uploaded_attachments.extend(self._upload_attachment(project_code, file))
+                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)

qase_python_commons-3.0.2b2/src/qase/commons/client/base_api_client.py

@@ -0,0 +1,88 @@
+import abc
+from typing import Union
+
+from qase.api_client_v1 import Project, AttachmentGet
+
+from ..models import Attachment
+
+
+class BaseApiClient(abc.ABC):
+    @abc.abstractmethod
+    def get_project(self, project_code: str) -> Union[Project, None]:
+        """
+        Load a project from Qase TestOps by code and return project data
+
+        :param project_code: project code
+        :return: project data or None if project not found
+        """
+
+        pass
+
+    @abc.abstractmethod
+    def get_environment(self, environment: str, project_code: str) -> Union[str, None]:
+        """
+        Load an environment from Qase TestOps by name and returns environment id
+
+        :param environment: environment name
+        :param project_code: project code
+        :return: environment id or None if environment not found
+        """
+        pass
+
+    @abc.abstractmethod
+    def complete_run(self, project_code: str, run_id: str) -> None:
+        """
+        Complete a test run in Qase TestOps
+
+        :param project_code: project code
+        :param run_id: test run id
+        :return: None
+        """
+        pass
+
+    @abc.abstractmethod
+    def _upload_attachment(self, project_code: str, attachment: Attachment) -> Union[AttachmentGet, None]:
+        """
+        Upload an attachment to Qase TestOps
+
+        :param project_code: project code
+        :param attachment: attachment model
+        :return: attachment data or None if attachment not uploaded
+        """
+        pass
+
+    @abc.abstractmethod
+    def create_test_run(self, project_code: str, title: str, description: str, plan_id=None,
+                        environment_id=None) -> int:
+        """
+        Create a test run in Qase TestOps
+
+        :param project_code: project code
+        :param title: test run title
+        :param description: test run description
+        :param plan_id: plan id
+        :param environment_id: environment id
+        :return: test run id
+        """
+        pass
+
+    @abc.abstractmethod
+    def check_test_run(self, project_code: str, run_id: int) -> bool:
+        """
+        Check if test run exists in Qase TestOps
+        :param project_code: project code
+        :param run_id: test run id
+        :return: True if test run exists, False otherwise
+        """
+        pass
+
+    @abc.abstractmethod
+    def send_results(self, project_code: str, run_id: int, results: []) -> None:
+        """
+        Send test results to Qase TestOps
+        :param project_code: project code
+        :param run_id: test run id
+        :param results: results data
+        :return: None
+        """
+        pass

{qase_python_commons-3.0.0 → qase_python_commons-3.0.2b2}/src/qase/commons/config.py

@@ -29,7 +29,7 @@ class ConfigManager:
         # Use _get_config method to get the value. If None, return default.
         value = self._get_config(key)
         if value_type and value_type == bool:
-            return self.parseBool(value or default)
+            return self.parseBool(value)
         return value or default
 
     def validate_config(self):
@@ -59,3 +59,6 @@ class ConfigManager:
         for key in keys[:-1]:
             config = config.get(key, {})
         return config.get(keys[-1], None)
+
+    def __str__(self):
+        return json.dumps(self.config, indent=4, sort_keys=True)

{qase_python_commons-3.0.0 → qase_python_commons-3.0.2b2}/src/qase/commons/loader.py

@@ -1,7 +1,7 @@
-from qaseio.api_client import ApiClient
-from qaseio.configuration import Configuration
-from qaseio.api.plans_api import PlansApi
-from qaseio.rest import ApiException
+from qase.api_client_v1.api_client import ApiClient
+from qase.api_client_v1.configuration import Configuration
+from qase.api_client_v1.api.plans_api import PlansApi
+from qase.api_client_v1.exceptions import ApiException
 
 import certifi
 

{qase_python_commons-3.0.0 → qase_python_commons-3.0.2b2}/src/qase/commons/logger.py

@@ -22,6 +22,10 @@ class Logger:
             with open(self.log_file, 'a') as f:
                 f.write(log)
 
+    def log_debug(self, message: str):
+        if self.debug:
+            self.log(message, 'debug')
+
     @staticmethod
     def _get_timestamp(format: str = "%Y%m%d_%H:%M:%S"):
         now = datetime.datetime.now()

{qase_python_commons-3.0.0 → qase_python_commons-3.0.2b2}/src/qase/commons/models/attachment.py

@@ -1,12 +1,14 @@
 import os
 import uuid
-from typing import Optional, Union
-from io import BytesIO, StringIO
 import json
 import pathlib
 
+from typing import Optional, Union
+from io import BytesIO, StringIO
+from .basemodel import BaseModel
+
 
-class Attachment:
+class Attachment(BaseModel):
     def __init__(self,
                  file_name: str,
                  mime_type: str,
@@ -40,10 +42,11 @@ class Attachment:
 
     def get_for_upload(self) -> BytesIO:
         if self.file_path:
-            return pathlib.Path(os.path.abspath(self.file_path))
+            with open(self.file_path, "rb") as fc:
+                content = BytesIO(fc.read())
         else:
             if isinstance(self.content, str):
-                content = BytesIO(self.content.encode('utf-8'))
+                content = BytesIO(bytes(self.content, 'utf-8'))
             elif isinstance(self.content, bytes):
                 content = BytesIO(self.content)
         content.name = self.file_name

qase_python_commons-3.0.2b2/src/qase/commons/models/basemodel.py

@@ -0,0 +1,7 @@
+import json
+
+
+class BaseModel:
+    def __str__(self) -> str:
+        return json.dumps(self, default=lambda o: o.__dict__ if hasattr(o, '__dict__') else str(o), indent=4,
+                          sort_keys=True)

{qase_python_commons-3.0.0 → qase_python_commons-3.0.2b2}/src/qase/commons/models/relation.py

@@ -1,10 +1,13 @@
-class RelationSuite(object):
+from .basemodel import BaseModel
+
+
+class RelationSuite(BaseModel):
     def __init__(self, suite_id: int, title: str) -> None:
         self.suite_id = suite_id
         self.title = title
 
 
-class Relation(object):
+class Relation(BaseModel):
     def __init__(self, type: str, data: RelationSuite):
         self.type = type
         self.data = data

{qase_python_commons-3.0.0 → qase_python_commons-3.0.2b2}/src/qase/commons/models/result.py

@@ -1,8 +1,10 @@
-from typing import Type, Optional, Union, Dict, List
-from pathlib import PosixPath
 import time
 import uuid
 import json
+
+from typing import Type, Optional, Union, Dict, List
+from pathlib import PosixPath
+from .basemodel import BaseModel
 from .step import Step
 from .suite import Suite
 from .attachment import Attachment
@@ -10,7 +12,7 @@ from .relation import Relation
 from .. import QaseUtils
 
 
-class Field:
+class Field(BaseModel):
     def __init__(self,
                  name: str,
                  value: Union[str, list]):
@@ -18,7 +20,7 @@ class Field:
         self.value = value
 
 
-class Execution(object):
+class Execution(BaseModel):
     def __init__(self,
                  status: Optional[str] = None,
                  end_time: int = 0,
@@ -47,7 +49,7 @@ class Execution(object):
         self.duration = (int)((self.end_time - self.start_time) * 1000)
 
 
-class Request(object):
+class Request(BaseModel):
     def __init__(self,
                  method: str,
                  url: str,
@@ -65,7 +67,7 @@ class Request(object):
         self.response_body = response_body
 
 
-class Result(object):
+class Result(BaseModel):
     def __init__(self, title: str, signature: str) -> None:
         self.id: str = str(uuid.uuid4())
         self.title: str = title
@@ -137,7 +139,3 @@ class Result(object):
 
     def set_run_id(self, run_id: str) -> None:
         self.run_id = run_id
-
-    def to_json(self) -> str:
-        return json.dumps(self, default=lambda o: o.__str__() if isinstance(o, PosixPath) else o.__dict__,
-                          sort_keys=False, indent=4)

{qase_python_commons-3.0.0 → qase_python_commons-3.0.2b2}/src/qase/commons/models/run.py

@@ -1,8 +1,11 @@
 import json
+
 from typing import Optional, List
 
+from .basemodel import BaseModel
+
 
-class RunExecution(object):
+class RunExecution(BaseModel):
     def __init__(self,
                  start_time: float,
                  end_time: float,
@@ -17,7 +20,7 @@ class RunExecution(object):
         self.cumulative_duration += result["execution"]["duration"]
 
 
-class RunStats(object):
+class RunStats(BaseModel):
     def __init__(self) -> None:
         self.passed = 0
         self.failed = 0
@@ -41,7 +44,7 @@ class RunStats(object):
             self.muted += 1
 
 
-class Run(object):
+class Run(BaseModel):
     def __init__(self,
                  title: str,
                  start_time: float,
@@ -60,9 +63,6 @@ class Run(object):
         self.suites = suites
         self.environment = environment
 
-    def to_json(self) -> str:
-        return json.dumps(self, default=lambda o: o.__dict__, sort_keys=False, indent=4)
-
     def add_result(self, result: dict):
         compact_result = {
             "id": result["id"],

{qase_python_commons-3.0.0 → qase_python_commons-3.0.2b2}/src/qase/commons/models/step.py

@@ -1,8 +1,10 @@
-from enum import Enum
-from typing import Optional, Union, Dict, List, Type
 import time
 import uuid
+
+from enum import Enum
+from typing import Optional, Union, Dict, List, Type
 from .attachment import Attachment
+from .basemodel import BaseModel
 
 
 class StepType(Enum):
@@ -14,27 +16,27 @@ class StepType(Enum):
     SLEEP = 'sleep'
 
 
-class StepTextData(object):
+class StepTextData(BaseModel):
     def __init__(self, action: str, expected_result: Optional[str] = None):
         self.action = action
         self.expected_result = expected_result
 
 
-class StepAssertData(object):
+class StepAssertData(BaseModel):
     def __init__(self, expected: str, actual: str, message: str):
         self.expected = expected
         self.actual = actual
         self.message = message
 
 
-class StepGherkinData(object):
+class StepGherkinData(BaseModel):
     def __init__(self, keyword: str, name: str, line: int):
         self.keyword = keyword
         self.name = name
         self.line = line
 
 
-class StepRequestData(object):
+class StepRequestData(BaseModel):
     def __init__(self, request_body: str, request_headers: Dict[str, str], request_method: str, request_url: str):
         self.response_headers = None
         self.response_body = None
@@ -60,17 +62,17 @@ class StepRequestData(object):
         self.response_headers = response_headers
 
 
-class StepDbQueryData(object):
+class StepDbQueryData(BaseModel):
     def __init__(self, query: str, expected_result: str):
         self.query = query
 
 
-class StepSleepData(object):
+class StepSleepData(BaseModel):
     def __init__(self, duration: int):
         self.duration = duration
 
 
-class StepExecution(object):
+class StepExecution(BaseModel):
     def __init__(self, status: Optional[str] = 'untested', end_time: int = 0, duration: int = 0):
         self.start_time = time.time()
         self.status = status
@@ -88,7 +90,7 @@ class StepExecution(object):
         self.duration = int((self.end_time - self.start_time) * 1000)
 
 
-class Step(object):
+class Step(BaseModel):
     def __init__(self,
                  step_type: StepType,
                  id: Optional[str],

{qase_python_commons-3.0.0 → qase_python_commons-3.0.2b2}/src/qase/commons/models/suite.py

@@ -1,9 +1,11 @@
-from typing import List, Optional
 import uuid
 
+from typing import List, Optional
+
+from .basemodel import BaseModel
 
-class Suite():
 
+class Suite(BaseModel):
     def __init__(self, title: str, description: Optional[str] = None, parent_id: Optional[str] = None):
         self.title = title
         self.description = description